久久91亚洲人成电影网站,亚洲欧洲日本天天堂在线观看,国产亚洲精品仙踪林在线播放

��其自然EVO — Thu, 13 Mar 2014 03:34:00 GMT

　　�q�是我在从事�|�站自动化测�?/strong>�?a target="_self" style="word-break: break-all; color: #202859; line-height: normal !important;">工作当中构徏出的一�?#8220;生态系�l?#8221;�?#8220;生态系�l?#8221;�q�个概念是我从公司的前辈�w�上学到的，他一直以来都认�ؓ(f��)自动化测试�h员不应仅仅局限于�~�写��试代码�Q�还应该让整个自动化��试的过�E�（��试代码的持�l�集成、分发、执行等�Q�都自动化，形成一�?#8220;�pȝ��”�Q�这个系�l�的自动化程度越高，自动化测试�h员就��省力�?/div>
　　一、概�?/strong>
　　�q�里我画了一张示意图�Q?/div>
　　之所以称之�ؓ(f��)“生态系�l?#8221;�Q�是因�ؓ(f��)建成之后需要的��Zؓ(f��)�q�涉很少�Q�其余的旉��都是�pȝ��内部循环�q�作。作��动化��试人员的你只需要提交代码，之后便可以在AutomationDashboard上看到运行的�l�果了，其余的事情都��q��l�内部消化。当�Ӟ��l�果的分析还是需要�h来完成，机器�q�没有聪明到可以灉|��分析出各�U�各栯��case fail掉的原因�?/div>
　　我们可以把整个系�l�看作一个黑盒子�Q�那么上面的囑֏�以变成：(x��)
　　实际上这里画的�h不仅限于自动化测试�h员，也可以是�Q?/div>
　　�Q?�Q��品的��理者，比如产品�l�理需要从自动化回归测试知道这�ơrelease有无推迟风险�Q?/div>
　　�Q?�Q�团队的��理者，比如开发经理、QA�l�理需要从自动化的daily/weekly regression知道最�q�的代码质量如何�Q?/div>
　　�Q?�Q�开发�h员，他们也许�?x��)想通过quick regression�Q�提交的产品代码被部�|�到��试环境之后�q�行的测试）知道自己刚提交的代码有没有破坏系�l�的基本功能�Q?/div>
　　�Q?�Q�其他帮忙做自动化测试的开发�h员、刚刚开�?a target="_self" style="word-break: break-all; color: #202859; line-height: normal !important;">学习(f��n)�~�写自动化测试代码的手动��试人员�Q�他们不必关心生态系�l�的内部实现�?/div>
　　二、实�?/strong>
　　说完概念�Q�接下来该说说具体实��C��。我�q�里讲的是我认�ؓ(f��)最适合我所��试的��品的实现�Q�工具不止一�U�，方式不止一�U�。Jenkins可以用TeamCity或其它CI替换�Q�git也可以是svn或tfs�Q�AutomationDahsboard可以�?NET、SpringMVC、ROR�{�等实现�Q�运行测试的slave可以是Windows/Linux/Mac�Q�土豪！�Q�，��M��选择一�U�最适合你所��试的��品的实现。还有一点就是自动化��试代码是用关键字驱动思想实现的，�q�是另外一个话题了�Q�有旉��另外写篇文�?/div>
　　好，�q�入正题。依�ơ说说系�l�的每个重要�l�成部分吧：(x��)
　　1、SCM�Q�Source Code Management�Q�。我选的是git�Q�可以是git服务器（公司自己搭徏了一个git server�Q�，也可以是一个bare repo�Q�http://www.saintsjd.com/2011/01/what-is-a-bare-git-repository/�Q?�?/div>
　　2、CI�Q�continuous integration�Q�。我选的是部�|�方�ѝ��插件丰富的Jenkins�?/div>
　　它的职责是：(x��)
　　�Q?�Q�从git上取��Z��码，build�Q?NET对应msbuild�Q�如果是ruby则不用build了，直接部��v卛_��Q�；
　　�Q?�Q�把build好的*.dll部��v�Q�这里即是拷贝）到所有的slave上；
　　�Q?�Q�启动或停止所有slave上的AutomationService�Q�后面还�?x��)讲到AutomationService�Q�，从而控制测试的执行�?span style="font-size: 11.818181991577148px; line-height: 21.60000228881836px;">我在Jenkins的这些个job配置��h��q�是比较�J�琐的，要细讲又可以另外写一��文了。这里就特别提到两个很实用的插�g吧：(x��)
　　�Q?�Q�Parameterized Trigger Plugin�Q�https://wiki.jenkins-ci.org/display/JENKINS/Parameterized+Trigger+Plugin�Q�：(x��)可以在一个build step中触发其它project的build�?/div>
　　它最有用的就是这�?#8220;Block until the triggered projects finish their builds”选项�Q�勾上的话Jenkins��p��在所有trigger的project完成build之后�Q�而非仅仅trigger其它project的build�Q�不�{�它们完成就�l�箋下一个build step�Q�再�l�箋下一个build step�Q�做到真正的依次执行每个build step�?/div>
　　�Q?�Q�NodeLabel Parameter Plugin�Q�https://wiki.jenkins-ci.org/display/JENKINS/NodeLabel+Parameter+Plugin�Q�：(x��)在所�?#8220;Possible nodes”标有指定标签�Q?#8220;Label”�Q�的Jenkins节点�Q�就是Jenkins master或Jenkins slave�Q�上触发指定project�Q�被触发的project是参数化的）�?/div>
　　比如我有一个project�?#8220;StartClassicROLATServiceOnAllNodes”�Q�它有一个build step是这栯��定的�Q?/div>
　　再来看看“StartClassicROLATServiceOnASingleNode”�q�个project的设定：(x��)
　　�q�个project有一个Node�c�d��的参敎ͼ�参数�?#8220;NodeX”与之前Label Factory中的“NodeX”对应�Q?#8220;Possible nodes”选的�?#8220;ALL”�Q�那么列出的所有node�Q�master�?0.107.122.152�?0.107.122.153�?0.107.122.154�Q�都在判断范围之内（判断其是否有“Node”标签�Q�有则执行project�Q��?/div>
　　另外�Q�列出的所有node我都为其加了一�?#8220;Node”标签�?/div>
　　�q�样�Q�当我trigger “StartClassicROLATServiceOnAllNodes”之后�Q�就�?x��)在master�?0.107.122.152�?0.107.122.153�?0.107.122.154�q?个node上同时执�?#8220;StartClassicROLATServiceOnASingleNode”�?br />
　3、AutomationDashboard�Q�这里姑且译�?#8220;自动化测试控刉��?#8221;吧�?/strong>实际上它应该和Jenkins一起�ƈ�U�控刉��板，不过因�ؓ(f��)Jenkins有API可以调用�Q�所以想做的��M��者也是可以统一成一个web界面的。这个dashboard完全是用.NET+IIS+SQLServer一点点从数据库设计构徏、数据访问层、业务层、表现层做�v来的�Q�要�l�讲……�?#8230;…又会(x��)是另外一��文了（Oh man, not again!�Q�。反正我觉得�Q�虽然我是做自动化测试工作的�Q�但不应该把自己局限于��试。�ؓ(f��)了更好地�q�行自动化测试，开发网站、安装配�|�虚拟机以及其它要用到的工具�Q�都应该抽时间去学习(f��n)、掌握�?/div>
　　好，来说说这个dashboard。这里只讲两个主要组成部分，一个网站（以下��U�dashboard�Q�、一个Windows Service�Q�以下简�U�ATService�Q�和一个console application�Q�以下称ConsoleRunner�Q�：(x��)
　　�Q?�Q�dashboard�Q�它的主要功能：(x��)
　　a、展�C�测试的�q�行状况�Q�有多少正在�q�行/执行完毕�Q�分别在哪台slave上执行等�{��?/div>
　　b、通过call Jenkins的API来trigger Jenkins的job�Q�间接控制测试的执行�?/div>
　　c、展�C�测试的�l�果�Q�发生错误的是哪个case、出错时间、错误信息、代码回溯（stack trace�Q�、甚臛_��以包含一张出错时的截图�?/div>
　　主要界面如下�Q?/div>
　　a、Summary�Q�顾名思义是汇��M��息，case有多��pass多少fail、case按分�c�L��一�c�L��多少�{�等。（其实�q�里我少做了一张很重要的图�Q�就是coverage饼状图）
　　b、Queue�Q�测试队列，包含当前正在�q�行的、运行完的、等待运行的test fixture或test case�Q�依据测试工��L(f��ng)��不同�Q�NUnit、JUnit、RSpec�{�，fixture的叫法可能不同，��M��是包含多个test case的集合）。可以启动、停止、终止（�l�止之后可以清空�Q�测试执行或清空当前队列�?/div>
　　c、TestCase�Q�生态系�l�中的所有测试用例会(x��)展示在这里，可以看到它们最后一�ơ执行的旉��和状态（pass/fail�Q�，点击某条case可以跌��{到该条case的所有test result。可以按状态（pass/fail/other�Q�筛选用例，可以��N��部分用例重新执行、或重新执行所有fail的case�?#8220;Reload Test Cases”主要是考虑�?.dll文�g中的test case可能�?x��)在某次部��v之后发生变化�Q�需要重新加载。不�q�后来我修改了Jenkins里的job在每�ơ部�|�之后都自动重新加蝲�Q�所以这个按钮其实没什么用了�?/div>
　　d、TestSuite�Q�包含多个fixture的集合是一个suite。勾选多个suite点击“Run Suite”卛_��把这些suite中包含的fixture��d��到Queue�?/div>
　　�q�里的suite是对NUnit中的Category的一个补充，点击“New Suite”你可以�Q意选择fixture来组成自己想要的suite�Q?/div>
　　e、TestResult�Q�展�C�所有test case的运行结果，可以按test case id�q�行�{�选，点击TC#�q�一列的id��只昄��q�条case的结果�?/div>
　　点右边的蓝色“i”图标可以跛_��q�条�l�果的详�l�页面，截图功能暂未启用�Q�根据RunnerMessage和RunnerStackTrace可以知道报错的代码位�|�，�q�而尝试重现问题�?/div>
　�Q?�Q�ATService。这个Windows Service�Q�slave都是Windows�Q�稍后会(x��)�Ԍ��被安装到了每个slave上，用以向dashboard询问“现在有没有分配给我的test fixture/case�Q?#8221;�Q�如果有且当前slave�I�闲的话��抓�q�来�q�行�Q�运行完毕汇报结果�?/div>
　　�q�记得Queue�Q�队列）吧？无论你在TestCase�q�是TestSuite��面挑选了test case/suite惌��q�行�Q�都只是把它们添加到队列当中�Q�准��地说就是往Queue�q�张数据库表中INSERT记录�Q�，而不�?x��)给它们分配slave。只有当Jenkins启动了slave上的ATService之后�Q�ATService才会(x��)去Queue表中自己抓取�Q�就是打上标记说�q�条fixture/case已经有主了，其它slave��׃��?x��)再��L��Q�还没有�q�行�q�且没有分配有slave的test fixture/case�?/div>
　　�Q?�Q�ConsoleRunner�Q�最开始的那个图中没有��d��来。这个console�E�序主要供Jenkins调用。Jenkins不是可以让job定时�q�行么？正好�Q�定时调用这个console application�Q�传几个参数�Q�就可以在指定时间往Queue里填充f(xi��)ixture/case�Q�然后再启动ATService开始执行测试。这样就能实现quick/daily/weekly/full regression的无人值守�q�行了�?/div>
　　4、Slave
　　我选择在Windows上运行测试：(x��)
　　�Q?�Q�公司IT一般只提供Windows操作�pȝ��的虚拟机
　　�Q?�Q��品在Windows上的用户占绝大多敎ͼ�其实�q�个有点废话�Q�桌面操作系�l�Windows依然是世界王者。诚�Ӟ��我自�׃��余时用Linux做开发，Mac在国内外也是相当��行的，但GoogleAnalytics昄��的统计结果就是大部分讉K��都来自Windows。什么，你说iOS/Android�Q�额……�U�d��端现在仍然是产品的短�?#8230;…�Q?/div>
　　如果选择Linux的话要注意下selenium webdriver的native event讑֮��Q�http://code.google.com/p/selenium/wiki/AdvancedUserInteractions#Native_events_versus_synthetic_events�Q��?/div>
　　关于��览器，Firefox、Chrome、IE皆可�Q�webdriver的浏览器兼容性已�l�很不错了。浏览器兼容性是个有点头疼的问题�Q�想支持很多��览器的话有时会(x��)增加很多开发、测试成本，我一般在Firefox上跑��p��够了。什么？数字�Q�马�Ӟ��企鹅�Q��?zh��n)�惛_��了，selenium官方不支持�?/div>
　　你能扑ֈ�多少台slave来执行测试？多多益善哦！找不到那么多实体机就自己配虚拟机吧，分布式运行可以给你的自动化测试生态系�l�装上火��！在更短的旉��内运行完更多��试�Q�从而更快地从测试中获得反馈�Q?/div>
　　嗯，差不多就�q�么多了。还有很多细节就留在之后的文中再说了。自我感觉这个生态系�l�还是有很多可以完善、增加的功能�Q�而且�q�个实现方式、运作机制可能也�q��适用于你所��试的��品，不过现在对于我测的��品来说是够用的了�?/div>
　　不管怎样实现�Q�我惌��辄��核心观点是：(x��)
　　做自动化��试不要局限于自动化测试代码的�~�写�Q�我们要自动化的不仅仅是manual test case�Q�还应包括整个automation test的process�Q�测试代码持�l�集成、部�|Ԍ��分发�Q�、执行、结果展�C�，自动化的环节��多、越��d��Q��ؓ(f��)你节�U�的旉��p��多，你可以用�q�些节约的时间做更有意义的事情。�h�c�d��明计��机�Q�用代码�~�写�E�序�Q�其实就是一�U�自动化的过�E�。以前要靠手工劳动完成的现在都交�l�电(sh��)脑做�?#8212;—服务器不正是勤勤��x��地重复执行着我们写好的程序么�Q�构��动化��试生态系�l�是同样的道理，因�ؓ(f��)机器能比人更可靠地完成重复劳动�?/div>
　　如果你还在手动拷�?.dll�Q�还需要打开NUnit手动执行��试�Q�还�?台机器上�q�行��试�Q�那么，现在��是该提高生产力的时候了�Q?/div>

��其自然EVO 2014-03-13 11:34 发表评论

操作�pȝ��中内存管理的��面�|�换��法

��其自然EVO — Fri, 01 Nov 2013 02:37:00 GMT

　　考虑下述��面走向�Q?/strong>
　　1�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?
　　当内存块数量分别�?�Ӟ��试问FIFO、LRU、OPT�q�三�U�置换算法的�~�页�ơ数各是多少?
　　�{�：(x��)�~�页定义为所有内存块最初都是空的，所以第一�ơ用到的��面都��生一�ơ缺��c�?/div>
　　当内存块数量�?�Ӟ��(x��)
　　发生�~�页中断的次��Cؓ(f��)16�?/div>
　　在FIFO��法中，先进入内存的��面被先换出。当��?要调入时�Q�内存的状态�ؓ(f��)4�?�?�Q�考查��?之前调入的页面，分别�?�?�?�?�Q�可�?为最先进入内存的�Q�本�ơ应换出�Q�然后把��?调入内存�?/div>
　　发生�~�页中断的次��Cؓ(f��)15�?/div>
　　在LRU��法中，最�q�最��用的��面被先换出。当��?要调入时�Q�内存的状态�ؓ(f��)5�?�?�Q�考查��?之前调入的页面，分别�?�?�?�Q�可�?为最�q�一�D�|��间内使用最��的�Q�本�ơ应换出�Q�然后把��?调入内存�?/div>
　　发生�~�页中断的次��Cؓ(f��)11�?/div>
　　在OPT��法中，在最�q�的��来才被讉K��的页面被先换出。当��?要调入时�Q�内存的状态�ؓ(f��)1�?�?�Q�考查��?后面要调入的��面�Q�分别�ؓ(f��)2�?�?�?#8230;�Q�可�?为最�q�一�D�|��间内使用最��的�Q�本�ơ应换出�Q�然后把��?调入内存�?/div>
　　OPT��法因�ؓ(f��)要知道后面请求的��|��Q�因此我觉得�q�个��法有个��小的bug,如果在某个请求中�Q�若在该��h��的页框之后的��|��序列中至��存在一个和当前内存块中不匹配的��|��Q�则按照内存块的��序�Q�从上往下）替换没有出现的页框。比如上面那个OPT例子。对于最后一个页框请求，因�ؓ(f��)6未命中，�?之后没有��h��的序列，因此应该替换3�Q�所以替换后的序列�ؓ(f��)6 �Q?2 �Q? 当然�Q�这只是针对做题而言�?/div>

��其自然EVO 2013-11-01 10:37 发表评论

��目实战�W�记之六�Q�团队徏讄��三种境界

��其自然EVO — Tue, 04 Jun 2013 02:32:00 GMT

　�l�过自己�ȝ��和项目经理们探讨�Q�认为项目或部门团队��可分��Z��个等�U�：(x��)
　　一、乌合之众，强权政治�Q�新手）
　　很多新手都会(x��)�l�历�q�样的过�E�，新组建的团队冲突不断�Q�大家对当各�U�制度措施，报以反感。�ؓ(f��)保证执行力和��目成功�Q�项目经理会(x��)选择强权压制�Q�尤其是技术比较好的项目经理。大�늚�逻辑�?#8220;我是老大�q�且我资深，要听我的”。最�l�的�l�果是大家对��目目标已经完全不感兴趣�Q�一些冲�H�升�U�到个�h情感冲突�Q�项目经理左右突击，上蹿下蟩�Q�甚是辛苦，忙碌�Q�确得不到大家的认可�?/p>
　　此时的项目经理至��需要做��C��点，才有可能�q�入下个阶段�Q�用杰克韦尔奇的两句话概况：(x��)
　　1�?#8220;在你成�ؓ(f��)领导以前�Q�成功只同自��q��成长有关。当你成为领��g��后，成功都同别�h的成长有兟�?#8221;
　　2�?#8220;世界上的每一个�h都想得到发言权和��严�Q�而且也应当得�?#8221;
　　所�?#8220;发言�?#8221;�Q�是指�h们希望有��Z��(x��)说出他们的思想�Q�拥有自��q��观点、看法、获得被們֐�的感受，无论他们的国�c�、性别、年龄或者文化背景如何�?/p>
　　所�?#8220;��严”�Q�是指�h们本能地和自发地希望�׃��自己�?a href="" target="_self" style="word-break: break-all; color: #202859; text-decoration: none; line-height: normal !important;">工作、努力和个性而得到尊重�?/p>
　　�q�个阶段之所以命名�ؓ(f��)乌合之众�Q�是因�ؓ(f��)大家对团队根本没有归属感�Q�甚臛_��弃团队，期望团队得到解散�Q�或者团队目标达成时�Q��ƈ没有取得成就的感觉，而是有终于熬�q�来的感触�?/p>
　　二、尊重，民主�C�会(x��) �Q�老手�Q?/strong>
　　在经历过挫折或是老前辈们的谆谆教导后�Q�新手往往都能�q�入�q�个阶段。当然有些厉害的人有时也�?x��)自��p��到这个阶�D�c��但是这个阶�D�里的�h�Q�也有高下之分。在�q�个阶段的�h�Q�往往可以带团队时�Q�往往可以做到�Q?/p>
　　1、尊重，�a�路开�?/p>
　　不把人当做机器。制定计划，措施�Ӟ��都可以征求的大家意见�Q�当然计划定下来后，执行时是不能含糊的�?/p>
　　2、善用�h才，培养人才
　　团队里有人才�Ӟ��?x��)��用授权等方式调用�q�些人的�U�极性，而不是幼�E�的打压�Q��ƈ且在团队里没有�h才时�Q�能够积极选拔备选�h员，�q�给予锻炼机�?/p>
　　3、分享荣�?/p>
　　�q�个阶段的项目经理，在交��中�Q�会(x��)摈弃�?#8220;我怎么��P��怎么�?#8221;�Q�多使用“我们�Q�我们团队怎么�?#8221;�Q�尤其是在面对表扬和荣誉时。在��目�l�内也想方设法树(w��i)立榜��P��q�且非常愿意�q�些��自己的上�U�所��L(f��ng)��Q�愿意�ؓ(f��)�q�些��个好前程�?/p>
　　4、坦�?/p>
　　坦诚是相处的长远之计�Q�而忽�(zh��n)�，��d��D��些手�D�只能短期效应，�q�在长期上让自己的�h格受损。关于这炚w��目经理大多做得程度不一�Q�有时说��Z��些不开心的事，是需要勇气的�Q�例如在�l�效沟通时。但是这个阶�D늚��目�l�理都了解它重要性�?/p>
　　5、团队信息透明
　　只有信息��_��透明�Q�大家才能够为项目出谋划�{�，才能有坦诚沟通的基础�Q�大家才能对��目归属�?#8220;垄断信息�Q�以昄��自己领导的地�?#8221;是愚蠢的人才�?x��)干的事�?/p>
　　�q�个阶段之所以命名�ؓ(f��)民主�C�会(x��)�Q�这个阶�D늚�价��D��是：(x��)民主计划�Q�严格执行，有付出有回报�Q�集体荣誉。第一个阶�D�到�W�二个阶�D�可能需要时间的�U�篏�Q�而第二个阶段到第三个阶段�Q�有时却可望而不可达�?/p>
　　三、激情，燃烧军团 �Q�高手）
　　�Ȁ情团队的充分必要前提是，团队负责人是非常有激情的。这点很关键�Q�一个打工者心态，没有把工作当成自�׃��业经营的人是不会(x��)带出有长久激情的团队。检视的原理�Q?#8220;看一下大家是不是��Z��同一个梦惌��走��C��L(f��ng)��”
　　要达成团队激情，臛_��具备以下几点�Q?/p>
　　1、老板风格�Q�老板要有分��n成功的决心，例如�Q�股��，期权�Ȁ�?/p>
　　2、企业文化，企业要有文化宣扬集体奋斗的精��，企业的��命�h(hu��n)��D��能够深入人心�Q�得到强烈响应，此时企业的创新精��，��是从内而外的，从下而上的，大家集体思考，集体�q�步�Q�集体创新�?/p>
　　3、有�Ȁ情的中层�Q�公�怸�层是企业的中��砥柱，如果每个中层是有�Ȁ情的�Q�扩散开来的影响力是很大的，反之�Q�则�Ȁ情容易变成口受��?/p>
　　�q�里典型的案例是sony的没落，从井深大的激情军团的消失�Q�井深大倡导”工作保证本��n��是一�U�强有力的激�?#8220;�Q�把�q�种理念能够深植公司是多么可怕，�Ȁ情可以创造出很多奇迹�?/p>
　　�U�翰·�U�特说过“如果你想建造一艘船�Q�首先要做的不是去采集木材、加工木板和分派工作�Q�而应该去唤�v��Z��对广阔无垠大��L(f��ng)��向往�?#8220; ��理者的本质是获得追随的人，一个企业，一个团队如果能够拥有一�Ҏ(gu��)��意追随公司成长的人，所产生的正向能量是无比巨大的�?/p>
　　�q�种境界的达到需要多方因素的促合�Q�颇��g��武侠里的天�h合一�Q�激情团队的��理��十分简单，保护�q�种�Ȁ情，员工�?x��)很自主的进行自我管理�?/p>
　　当然实际工作中，以上每个阶段不孤立存在，可能�?x��)存在一些阶�D늚�中间体�?/p>
相关链接�Q?/p>
��目实战�W�记之一�Q�高效会(x��)议的�l�织�Ҏ(gu��)��
��目实战�W�记之二�Q�风险管�?/a>
��目实战�W�记之三�Q�时间估��的三步�?/a>
��目实战�W�记之四�Q�团队徏设（��重�Q?/a>
��目实战�W�记之五�Q�里�E�碑��理

��其自然EVO 2013-06-04 10:32 发表评论

��其自然EVO — Fri, 21 Dec 2012 08:26:00 GMT

1.3 抽象工厂�Q�Abstract Factory�Q�模�?br />    抽象工厂模式可以向客��L(f��ng)��提供一个接口，使得客户端在不必指定产品具体�c�d��的情况下�Q�创建多个��品族中的产品对象。这��是抽象工厂模式的用意�?br />    每个模式都是针对一定问题的解决�Ҏ(gu��)��。抽象工厂模式面对的问题是多产品�{��l�构的系�l�设计�?br />    在学�?f��n)抽象工厂具体实例之前，应该明白两个重要的概念�?x��)产品族和产品�{��?br />    产品族：(x��)是指位于不同产品�{��l�构中，功能相关联的产品�l�成的家族。比如AMD的CPU和ADM芯片的主板，�l�成一个家族。Intel的CPU�?Intel芯片的主板，又组成一个家族。而这两个家族都来自于两个产品�{��Q�CPU�Q�主�ѝ��一个等�U�结构是��q��同的�l�构的��品组成，�C�意囑֦�下：(x��)

    理解�q�个产品�l�构是理解抽象工厂模式的关键所在，所以我不惜��p��旉��来画此图。如果领�(zh��n)�不到此囄��含义�Q�就无法区分工厂�Ҏ(gu��)��模式和抽象工厂模式的区别�?br />    从上囑֏�以看出，抽象工厂模式的每个工厂创造出来的都是一族��品，而不是一个或者一�l�。组是可以随意组合的�Q�其实两个就�q�点点差别，呵呵�Q�估计现在你已经差不多明白了抽象工厂模式的含义。不废话了，看个例子�Q�真相将大白于天下！

1.3.1 抽象工厂模式在农��Z��的实�?/strong>

1.3.1.1 背景

    聪明的农��Z��L��让自��q��庄园��来��有价��|��“农场”在经历了��单工厂模式和工厂模式后，不断的扩大生产。如今，再次面��(f��)新的大发展，一��w��要的工作��是引进塑料大棚技术，在大��里�U�植热带�Q�Tropical�Q�和亚热带（Northern�Q�的水果和蔬菜，用以满��市场需求，获取更大的利益�?/div>

1.3.1.2 产品角色�?/strong>

    �l�过分析�Q�对产品角色�q�行分析得出下图

    �l�过分析�Q�所谓的各个园丁其实��是工厂角色�Q�而蔬菜和水果则是产品角色。将抽象工厂模式用于农场中，�pȝ��设计囑֦�下：(x��)

1.3.1.4.1 抽象工厂�Q�Gardener.java
package com.lavasoft.patterns.abstractfactory.ybms;

/**
* Created by IntelliJ IDEA.
* FileName:Gardener.java
* User:    LavaSoft
* Date:    2006-12-5
* Time:    22:55:23
* 《Java与模式》（--阎宏博士著）��M��W�记
* 工厂模式--抽象工厂模式--一般性模式（农场应用�Q?br /> * ReadMe: 抽象工厂角色�Q�工厂接�?br /> */
public interface Gardener {

    public Fruit createFruit(String name);

1.3.1.4.2 抽象水果产品�Q�Fruit.java

package com.lavasoft.patterns.abstractfactory.ybms;

/**
* Created by IntelliJ IDEA.
* FileName:Fruit.java
* User:    LavaSoft
* Date:    2006-12-5
* Time:    22:54:15
* 《Java与模式》（--阎宏博士著）��M��W�记
* 工厂模式--抽象工厂模式--一般性模式（农场应用�Q?br /> * ReadMe: 抽象产品角色�Q�水果接�?br /> */
public interface Fruit {
}

1.3.1.4.3 抽象蔬菜产品�Q�Veggie.java
package com.lavasoft.patterns.abstractfactory.ybms;

/**
* Created by IntelliJ IDEA.
* FileName:Veggie.java
* User:    LavaSoft
* Date:    2006-12-5
* Time:    22:56:22
* 《Java与模式》（--阎宏博士著）��M��W�记
* 工厂模式--抽象工厂模式--一般性模式（农场应用�Q?br /> * ReadMe: 抽象产品角色�Q�蔬菜接�?br /> */
public interface Veggie {
}

1.3.1.4.4 热带水果�Q�TropicalFruit.java
package com.lavasoft.patterns.abstractfactory.ybms;

/**
* Created by IntelliJ IDEA.
* FileName:TropicalFruit.java
* User:    LavaSoft
* Date:    2006-12-5
* Time:    22:57:08
* 《Java与模式》（--阎宏博士著）��M��W�记
* 工厂模式--抽象工厂模式--一般性模式（农场应用�Q?br /> * ReadMe: 具体产品角色�Q�热带水�?br /> */
public class TropicalFruit implements Fruit {
    private String name;

}

1.3.1.4.5 热带蔬菜�Q�TropicalVeggie.java
package com.lavasoft.patterns.abstractfactory.ybms;

/**
* Created by IntelliJ IDEA.
* FileName:TropicalVeggie.java
* User:    LavaSoft
* Date:    2006-12-5
* Time:    22:58:03
* 《Java与模式》（--阎宏博士著）��M��W�记
* 工厂模式--抽象工厂模式--一般性模式（农场应用�Q?br /> * ReadMe: 具体产品角色�Q�热带蔬�?br /> */
public class TropicalVeggie implements Veggie {
    private String name;

    public TropicalVeggie(String name) {
        System.out.println("热带工厂为�?zh��n)�创徏了�?x��)热带水果�Q?+name);
    }

}

1.3.1.4.6 亚热带水果：(x��)NorthernFruit.java
package com.lavasoft.patterns.abstractfactory.ybms;

/**
* Created by IntelliJ IDEA.
* FileName:NorthernFruit.java
* User:    LavaSoft
* Date:    2006-12-5
* Time:    22:58:55
* 《Java与模式》（--阎宏博士著）��M��W�记
* 工厂模式--抽象工厂模式--一般性模式（农场应用�Q?br /> * ReadMe: 具体产品角色�Q�亚热带水果
*/
public class NorthernFruit implements Fruit {
    private String name;

    public NorthernFruit(String name) {
        System.out.println("亚热带工厂�ؓ(f��)�(zh��n)�创��Z��Q�亚热带水果�Q?+name);
    }

}

1.3.1.4.7 亚热带蔬菜：(x��)NorthernVeggie.java
package com.lavasoft.patterns.abstractfactory.ybms;

/**
* Created by IntelliJ IDEA.
* FileName:NorthernVeggie.java
* User:    LavaSoft
* Date:    2006-12-5
* Time:    22:59:36
* 《Java与模式》（--阎宏博士著）��M��W�记
* 工厂模式--抽象工厂模式--一般性模式（农场应用�Q?br /> * ReadMe: 具体产品角色�Q�亚热带蔬菜
*/
public class NorthernVeggie implements Veggie {
    private String name;

    public NorthernVeggie(String name) {
        System.out.println("亚热带工厂�ؓ(f��)�(zh��n)�创��Z��Q�亚热带蔬菜�Q?+name);
    }

}

1.3.1.4.8 热带工厂�Q�TropicalGardener.java
/**
* Created by IntelliJ IDEA.
* FileName:TropicalGardener.java
* User:    LavaSoft
* Date:    2006-12-5
* Time:    23:01:49
* 《Java与模式》（--阎宏博士著）��M��W�记
* 工厂模式--抽象工厂模式--一般性模式（农场应用�Q?br /> * ReadMe: 具体工厂角色�Q�热带工�?br /> */
public class TropicalGardener implements Gardener {
    public Fruit createFruit(String name) {
        return new TropicalFruit(name);
    }

    public Veggie createVeggie(String name) {
        return new TropicalVeggie(name);
    }
}

1.3.1.4.9 亚热带工厂：(x��)NorthernGardener.java
package com.lavasoft.patterns.abstractfactory.ybms;

/**
* Created by IntelliJ IDEA.
* FileName:NorthernGardener.java
* User:    LavaSoft
* Date:    2006-12-5
* Time:    23:00:31
* 《Java与模式》（--阎宏博士著）��M��W�记
* 工厂模式--抽象工厂模式--一般性模式（农场应用�Q?br /> * ReadMe: 具体工厂角色�Q�亚热带工厂
*/
public class NorthernGardener implements Gardener {
    public Fruit createFruit(String name) {
        return new NorthernFruit(name);
    }

    public Veggie createVeggie(String name) {
        return new NorthernVeggie(name);
    }
}

1.3.1.4.10 ��试�c�（客户端）�Q�TestApp.java
package com.lavasoft.patterns.abstractfactory.ybms;

/**
* Created by IntelliJ IDEA.
* FileName:TestApp.java
* User:    LavaSoft
* Date:    2006-12-5
* Time:    23:03:22
* 《Java与模式》（--阎宏博士著）��M��W�记
* 工厂模式--抽象工厂模式--一般性模式（农场应用�Q?br /> * ReadMe: ��试�c�（客户端）
*/
public class TestApp {
    private void test(){
        Veggie tv,nv;
        Fruit tf,nf;
        TropicalGardener tg=new TropicalGardener();
        NorthernGardener ng=new NorthernGardener();

        tv=tg.createVeggie("热带菜叶");
        nv=ng.createVeggie("东北甜菜");
        tf=tg.createFruit("��南椰子");
        nf=ng.createFruit("雪梨");
    }
    public static void main(String args[]){
        TestApp test=new TestApp();
        test.test();
    }
}

1.3.1.4.11 ��试�q�行�l�果
    热带工厂为�?zh��n)�创徏了�?x��)热带水果�Q�热带菜�?br />    亚热带工厂�ؓ(f��)�(zh��n)�创��Z��Q�亚热带蔬菜�Q�东北甜�?br />    热带工厂为�?zh��n)�创徏了�?x��)热带水果�Q��v南椰�?br />    亚热带工厂�ؓ(f��)�(zh��n)�创��Z��Q�亚热带水果�Q�雪�?/div>
    Process finished with exit code 0
    看完设计囑֒�源码�Q�原理已�l�很清楚了，�q�个模式应用很灵�z�，猴交�l�你了，看你怎么玩它�Q�哈哈哈哈。。。�?/div>
1.3.1.5 奛_��丄��造万�?br />    奛_��丄��造物的故事很适合在这里�D例子�Q�女娲的�l�_��按照阴阳划分�Q��品则按�h、兽划分。将抽象工厂模式用于奛_��造万物的模拟�pȝ��设计中。系�l�设计图如下�Q?/div>

��其自然EVO 2012-12-21 16:26 发表评论

跟屌丝大哥学�?f��n)设计模�?-工厂�Ҏ(gu��)��模式

��其自然EVO — Wed, 19 Dec 2012 08:25:00 GMT
     摘要: 东汉《风俗通》记录了一则神话故事：(x��)“开天辟辟，未有人民�Q�女娲搏�Q�黄土作�?#8230;…”�Q�讲�q�的内容��是大家非常熟�?zh��n)�的女娲造�h的故事。开天辟��C��初，大地上�ƈ没有生物�Q�只有苍茫大圎ͼ��U��a而洁净的自然环境，寂静而又寂寞�Q�于是女娲决定创造一个新物种�Q�即人类�Q�来增加世界的繁荣，怎么刉��呢�Q?nbsp;     别忘了女娲是��仙�Q?..  阅读全文

��其自然EVO 2012-12-19 16:25 发表评论

跟屌丝大哥学�?f��n)设计模�?--生成器模�?Builder)解析例子

��其自然EVO — Tue, 18 Dec 2012 09:16:00 GMT

生成器模式属于对象结构型模式�Q�其意图是将一个复杂对象的构徏与他的表�C�分��，使得同样的构建创��E�可以创��Z��同的表示�?/span>

适用性：(x��)

1.         当创建复杂对象的��法应该独立于该对象的组成部分以及他们的装配方式�?/span>

2.         当构造过�E�必��d��许被构造的对象有不同的表示时�?/span>

参与�?/span>:

       生成�?/span>Builder:为创��Z��?/span>Product对象的各个部件指定抽象接�?/span>(AnimalBuilder)�?/span>

       具体生成�?/span>ConcreteBuilder:实现Builder接口一构造和装配该��品的各个部�g�?/span>

                     定义�q�明��他所创徏的表�C�，

                     提供一个检索��品的接口(getAnimal)�?/span>

导向器：(x��)构徏一个适用Builder对象的接口�?/span>

Product�Q?/span>Checken,pig�Q?/span>:表示被构造的复杂对象�?/span>ConcreteBuilder创徏该��品的内部表示�q�定义它的装配过�E�，包含定义�l�成部�g的类�Q�包括将�q�些部�g装配成最�l�的产品�?img alt="" src="http://img1.51cto.com/attachment/200707/200707141184406082109.gif" border="0" />

�?

当客户需要一个��品时�Q�把需要的参数传递个导向器，导向器根据传递的参数调用具体的生成器�Q�具体的生成器通过一�p�d��的操�?/span>(getAnimal()通过调用其它的接口方法实�?/span>)最�?x��)返回一个��品�?/span>

Bridge模式的优点：(x��)

1.         它��你可以改变一个��品的内部表示�Q?/span>Builder对象提供�l�导向器一个构造��品的抽象接口�Q�该接口使得生成器可以隐藏这个��品的表示和内部结构，他同时也隐藏了该产品是如何装配的�Q�因��Z�品时通过抽象接口构造的(注：(x��)本例子把接口的实现放在具体类中了)�Q�你在改变该产品的内部表�C�时所要做的只是定义一个新的生成器�?/span>

2.         他将构造代码和表示代码分开�Q�这有点�c�M��于模板模式。所不同的是模版模式最�l�是完成复杂的工作，而生成器的目的是要生成一个复杂的对象�?/span>

3.         他��得你�Ҏ(gu��)��造过�E�进行更加精�l�的控制�?/span>Builder模式是在导向者的控制下一步一步构造��品的�Q�仅当该产品完成�Ӟ��导向者才从生成器中取回��品。因�?/span>Builder模式能更好的反映产品的构造过�E�，使你可以更精�l�的控制构徏�q�程�Q�从而能更精�l�的控制所的��品的内部�l�构�?/span>

代码�C�Z��:

AnimalBuilder�Q�代�?/span>

package builder;

public interface AnimalBuilder{

    public void buildName();

    public void buildLegs();

    public void buildMeat();

    public Animal getAnimal();

}

ChickenBuilder�?/span>代码�Q?/span>

package builder;

public class ChickenBuilder implements AnimalBuilder{

    private Animal chicken = null;

    public ChickenBuilder(){

       chicken = new Animal();

    }

    public void buildName(){

       chicken.setName("chicken");

    }

    public void buildLegs(){

       chicken.setLegs(2);

    }

    public void buildMeat(){

       chicken.setMeat("chicken");

    }

    public Animal getAnimal(){

       buildName();

       buildLegs();

       buildMeat();

       return chicken;

    }

}

Animal代码�Q?/span>

package builder;

public class Animal{

    private String name;

    private String meat;

    private int legs;

    public String getName(){

       return name;

    }

    public String getMeat(){

       return meat;

    }

    public int getLegs(){

       return legs;

    }

    public void setName(String aName){

       name = aName;

    }

    public void setMeat(String aMeat){

       meat = aMeat;

    }

    public void setLegs(int alegs){

       legs = alegs;

    }

}

Director代码�Q?/span>

package builder;

public class Director{

    public Animal getAnimal(String aName){

       if(aName.equals("chicken")){

           return new ChickenBuilder().getAnimal();

       }

       else if(aName.equals("pig")){

           return new PigBuilder().getAnimal();

       }

       else return null;

    }

}

客户端代码：(x��)

package builder;

public class Client{

    public static void description(Animal animal){

       String desc = "This animal is called "+animal.getName();

       desc +="\n Its meat is "+animal.getMeat();

       desc +="\n And it has "+animal.getLegs()+" legs.";

       System.out.println(desc);

    }

    public static void main(String[] args){

       String aName = "chicken";

       Director d = new Director();

       Animal animal =d.getAnimal(aName);

       description(animal);

       aName = "pig";

       animal = d.getAnimal(aName);

       description(animal);

    }

}

�l�论�Q�生成器模式使得客户可以更加�_��的控制一个对象的构徏�Q�每个具体的创徏者包含了创徏和装配一个特定��品的所有代码，�q�些代码只用写一�ơ，便可以被不同�?/span>Director使用�Q�从而可以装配出不同的对象�?/span>

��其自然EVO 2012-12-18 17:16 发表评论

��其自然EVO — Thu, 13 Dec 2012 03:53:00 GMT

动态代�?/p>
java中动态代理机制的引入使得代理模式的思想更加完善与进步，它允许动态的创徏代理�q�支持对动态的�Ҏ(gu��)��代理的方法进行调用。Java动态代理类位于Java.lang.reflect包下�Q�一般主要涉及到以下两个�c�：(x��)

(1). Interface InvocationHandler�Q�该接口中仅定义了一个方法Object�Q?span>invoke(Object obj,Method method, Object[] args)。在实际使用�Ӟ��W�一个参数obj一般是指代理类�Q�method是被代理的方法，如上例中的request()�Q�args��Ҏ(gu��)��的参数数�l�。这个抽象方法在代理�c�M��动态实现�?nbsp;

(2).Proxy�Q�该�c�d��为动态代理类�Q�作用类��g��上例中的ProxySubject�Q�其中主要包含以下内容：(x��)

Protected Proxy(InvocationHandler h)�Q�构造函敎ͼ�估计用于�l�内部的h赋倹{�?nbsp;

Static Class getProxyClass (ClassLoader loader, Class[] interfaces)�Q�获得一个代理类�Q�其中loader是类装蝲器，interfaces是真实类所拥有的全部接口的数组�?nbsp;

Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)�Q�返回代理类的一个实例，�q�回后的代理�c�d��以当作被代理�c�M��?可��用被代理�cȝ��在Subject接口中声明过的方�?�?nbsp;

所谓Dynamic Proxy是这样一�U�class�Q�它是在�q�行时生成的class�Q�在生成它时你必��L��供一�l�interface�l�它�Q�然后该class��宣�U�它实现了这些interface。你当然可以把该class的实例当作这些interface中的��M��一个来用。当然啦�Q�这个Dynamic Proxy其实��是一个Proxy�Q�它不会(x��)替你作实质性的工作�Q�在生成它的实例时你必须提供一个handler�Q�由它接��实际的工作�?下面我们通过动态代理来重新实现上面发送信息的例子�Q?/p>

在上面的例子基础上，我们先添加一个通过短信来发送消息的处理�c�：(x��)
public class SmsMessage implements MessageHandler {
@Override
public void sendMessage(String msg) {
// TODO Auto-generated method stub
System.out.println("SMS Message :" + msg+" sent !");
}
}
//动态代理类
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class DynamicMessageProxy implements InvocationHandler {
private static int count;
private MessageHandler msgHandler;
public DynamicMessageProxy(MessageHandler handler) {
msgHandler = handler;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub
System.out.println("++++++++=============+++++++++");
System.out.println("proxy:" + proxy.getClass());
System.out.println("method:" + method);
System.out.println("++++++++=============+++++++++");
if (args != null && args.length == 1 && checkMessage((String) args[0])) {
count++;
System.out.println("Message sent:" + count);
return method.invoke(msgHandler, args);
}
return null;
}
private boolean checkMessage(String msg) {
return msg != null && msg.length() > 10;
}
}
//下面是调�?br />import java.lang.reflect.Proxy;
public class MainClass {
private static void runProxy(MessageHandler handler) {
handler.sendMessage("message for test");
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// runProxy(new EmailMessage());
// System.out.println("++++++++++++++++Proxy++++++++++++++++++");
// runProxy(new MessageProxy());
MessageHandler handler = new EmailMessage();
runProxy(handler);
MessageHandler proxy = (MessageHandler) Proxy.newProxyInstance(
MessageHandler.class.getClassLoader(),
new Class[] { MessageHandler.class }, new DynamicMessageProxy(
handler));
runProxy(proxy);
System.out.println("++++++++++++++++++++++++++++++++++");
// 短信方式
handler = new SmsMessage();
runProxy(handler);
proxy = (MessageHandler) Proxy.newProxyInstance(MessageHandler.class
.getClassLoader(), new Class[] { MessageHandler.class },
new DynamicMessageProxy(handler));
runProxy(proxy);
}
}
下面��Z��上方法的输出�Q?br />message for test send!!
++++++++=============+++++++++
proxy:class $Proxy0
method:public abstract void MessageHandler.sendMessage(java.lang.String)
++++++++=============+++++++++
Message sent:1
message for test send!!
++++++++++++++++++++++++++++++++++
SMS Message :message for test sent !
++++++++=============+++++++++
proxy:class $Proxy0
method:public abstract void MessageHandler.sendMessage(java.lang.String)
++++++++=============+++++++++
Message sent:2
SMS Message :message for test sent !
以上例子中，通过调用Proxy.newProxyInstance�Ҏ(gu��)��创徏动态代理对象，该方法需要传入一�?�c�d��载器、一�l�希望代理实现的接口列表、InvocationHandler 接口的一个具体实现。动态代理可以将所有调用重定向到调用处理器�Q�通常我们�?x��)向该处理器传递一个时间对象的引用�?/span>invoke()�Ҏ(gu��)��中传递进来了代理对象�Q�当你需要区分请求来源时�q�是非常有用的，例如你可以通过判断传入的方法名屏蔽掉某些方法的执行�Q�动态代理机制�ƈ不是�?x��)很频繁使用的方法，它通常用来解决一些特定情况下的问题，因此不要盲目的�ؓ(f��)了��用而��用，要根据自��q��实际需求来军_��Q?/p>
动态代理的应用十分�q�泛�Q�在struts2的拦截器中就用到了动态代理机制。还是以买�R��ؓ(f��)例子�Q�现在用动态代理来实现�Q�其中不懂的接口�Ҏ(gu��)��查查Java api��׃��(x��)明白了，在此不多做解释，代码如下(注意PassengerProxy�c?�Q?
import java.lang.reflect.*;

public interface Passenger {
public void buyTicket();
}

public class RealPassenger implements Passenger {

@Override
public void buyTicket() {
   // TODO Auto-generated method stub
   System.out.println("购买了�R��?);
}
}

// 用动态代理实�?/p>
//InvocationHandler 是代理实例的调用处理�E�序 实现的接口�? 每个代理实例都具有一个关联的调用处理�E�序。对代理实例调用�Ҏ(gu��)��Ӟ��对�Ҏ(gu��)��调用�q�行�~�码�q�将其指�z�ֈ�//它的调用处理�E�序�?invoke �Ҏ(gu��)��?br />public class PassengerProxy implements InvocationHandler {
public Object obj;

// 把obj交给代理�c?br />public Object obj(Object obj) {
   this.obj = obj;
   return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
     .getClass().getInterfaces(), this);
}

@Override
public Object invoke(Object proxy, Method method, Object[] args)
    throws Throwable {
   // TODO Auto-generated method stub
   System.out.println("通过代理");
   method.invoke(obj, args);
   return null;
}
}

public class Client {
public static void main(String[] args) {
   PassengerProxy proxy = new PassengerProxy();
   Passenger passenger = (Passenger) proxy.obj(new RealPassenger());
   passenger.buyTicket();
}
}
再来一个更牛的例子
/**
* �怺�接口
*
* @author zhengt
* @time Jun 3, 2095 3:13:03 PM
*/
public interface XiangQinInterface {
    /**
     * �怺��Ҏ(gu��)��
     */
    public void xiangQin();
}
/**
* 张三�怺�实现�c?nbsp;
*
* @author zhengt
* @time Jun 3, 2095 3:14:48 PM
*/
public class ZhangSanXiangQinInterfaceImpl implements XiangQinInterface {
    public void xiangQin() {
        System.out.println("张三�ȝ��Ԍ��娶个漂亮老婆�?);
    }
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
* �怺�可是一辈子的大事，�怺�前要准备一下，打扮得帅气些�?nbsp;
*
* @author zhengt
* @time Jun 3, 2095 3:15:48 PM
*/
public class ReadyInvocationHandler implements InvocationHandler {
    //�怺�接口的实现类�Q�也��是张三�怺��c?nbsp;
    private Object zhangSan = null;

    public ReadyInvocationHandler(Object realSubject) {
        this.zhangSan = realSubject;
    }

    public Object invoke(Object proxy, Method m, Object[] args) {
        Object result = null;
        try {
            /**
             * 动态代理类$Proxy0调用xiangQin�Ҏ(gu��)��时会(x��)调用它自��q��xiangQin�Ҏ(gu��)��Q?nbsp;
             * 而它自己的xiangQin�Ҏ(gu��)��里面调用的是super.h.invoke(this, , )�Q�也��是父类Proxy的h的invoke�Ҏ(gu��)��Q?nbsp;
             * 也就是ReadyInvocationHandler�cȝ��invoke�Ҏ(gu��)��?nbsp;
             * 所以，invoke(Object proxy, Method m, Object[] args)�U�的proxy实际上就是动态代理类$Proxy0�Q?nbsp;
             * 如果你将其强转成XiangQinInterface然后调用它的xiangQin�Ҏ(gu��)��Q�然后它?y��u)�׃�?x��)调用super.h.invoke(this, , )�Q�这样就�?x��)死循环�?nbsp;
             */
            /**
             * �|�上关于�q�里最多问题就是Object proxy攑֜��q�里用来做什么呢�Q�这个我也不知道�Q?nbsp;
             * 不过臛_��我们知道它到底是个什么东西，具体做什么用嘛就不得而知�?nbsp;
             */
            System.out.println(proxy.getClass().getSimpleName());
            System.out.println("张三�怺�前，代理人给他打扮了打扮�?);
            result = m.invoke(zhangSan, args);
        } catch (Exception ex) {
            System.exit(1);
        }
        return result;
    }
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
* 张三来到了婚介所(�怺�现场)�Q�开始相二Ӏ?nbsp;
*
* @author zhengt
* @time Jun 3, 2095 3:17:16 PM
*/
public class HunJieSuo {
    public static void main(String args[]) {
        //先将张三�怺��q�个�怺�的实现类实例化，也就是得到XiangQinInterface接口的一个实例对�?nbsp;
        XiangQinInterface zhangSan = new ZhangSanXiangQinInterfaceImpl();
        /**
         * 得到ZhangSanXiangQinInterfaceImpl�q�个�cȝ��一个代理类�Q�同时�ؓ(f��)代理�cȝ��定了一个处理类ReadyInvocationHandler�?nbsp;
         * 听着很绕口，其实��是每次调用ZhangSanXiangQinInterfaceImpl�q�个子类的xiangQin�Ҏ(gu��)��Ӟ��
         * 不是zhangSan�q�个ZhangSanXiangQinInterfaceImpl�cȝ��实例去调用，
         * 而是�q�个ZhangSanXiangQinInterfaceImpl的代理类ReadyInvocationHandler去调用它自己的invoke�Ҏ(gu��)��,
         * �q�个invoke�Ҏ(gu��)��里呢可以调用zhangSan�q�个实例的xiangQin�Ҏ(gu��)��
         */
        /**
         * 在java�U�怎样实现动态代理呢
         * �W�一步，我们要有一个接口，�q�要有一个接口的实现�c�，而这个实现类呢就是我们要代理的对象，
         * 所谓代理呢也就是在调用实现�cȝ��Ҏ(gu��)��Ӟ��可以在方法执行前后做额外的工作，�q�个��是代理�?nbsp;
         * �W�二步，我们要自己写一个在要代理类的方法执行时�Q�能够做额外工作的类�Q�而这个类必须�l�承InvocationHandler接口�Q?nbsp;
         * ��Z��么要�l�承它呢�Q�因��Z��理类的实例在调用实现�cȝ��Ҏ(gu��)��的时候，不会(x��)调真正的实现�cȝ��q�个�Ҏ(gu��)��Q?nbsp;
         * 而是转而调用这个类的invoke�Ҏ(gu��)��Q��承时必须实现的方法）�Q�在�q�个�Ҏ(gu��)��中你可以调用真正的实现类的这个方法�?nbsp;
         * �W�三步，在要用代理类的实例去调用实现�cȝ��Ҏ(gu��)��的时候，写出下面两段代码�?nbsp;
         */
        XiangQinInterface proxy = (XiangQinInterface) Proxy.newProxyInstance(
                zhangSan.getClass().getClassLoader(),
                zhangSan.getClass().getInterfaces(),
                new ReadyInvocationHandler(zhangSan));
        proxy.xiangQin();
        /**
         * �q�里要解释下中部那段镉K��的代码的意思，以及具体做了哪些工作�Q?nbsp;
         * �W�一�Q�根据zhangSan.getClass().getClassLoader()�q�个要代理类的类加蝲器和
         * zhangSan.getClass().getInterfaces()要代理类所实现的所有的接口
         * 作�ؓ(f��)参数调用Proxy.getProxyClass(ClassLoader loader, Class... interfaces)
         * 的方法返回代理类的java.lang.Class对象�Q�也��是得到了java动态生成的代理�c?Proxy0的Class对象�?nbsp;
         * 同时�Q�java�q�让�q�个动态生成的$Proxy0�c�d��C��要代理类的实现的所有接口，�q��承了Proxy接口�?nbsp;
         * �W�二�Q�实例化�q�个动态生成的$Proxy0�cȝ��一个实例，实例化代理类的构造函��Cؓ(f��)Proxy(InvocationHandler h)�Q?nbsp;
         * 也就是说要实例化�q�个动态生成的$Proxy0�c�，必须�l�它一个InvocationHandler参数�Q�也��是我们自己实现的用来在代理�c?nbsp;
         * �Ҏ(gu��)��执行前后做额外工作的�c�ReadyInvocationHandler�?nbsp;
         * �q?�D�代�?Proxy.newProxyInstance(zhangSan.getClass().getClassLoader(),zhangSan.getClass().getInterfaces(),new ReadyInvocationHandler(zhangSan))
         * 得到的其实是一个类名叫$Proxy0 extends Proxy implements XiangQinInterface的类�?nbsp;
         * �W�三�Q�将�q�个$Proxy0�c�d��制�{型成XiangQinInterface�c�d��Q�调用xiangQin�Ҏ(gu��)��?nbsp;
         */
    }
}
�|�上看到一个牛��q�这个动态代理的源代码，现把�|�址留在�q�里�Q�希望对�|�友们有帮助�?
http://hi.baidu.com/malecu/blog/item/45d4952b31bc0e27d52af17a.html
在目前的Java开发包中包含了对动态代理的支持�Q�但是其实现只支持对接口的的实现�?

　　其实��C��要通过是java.lang.reflect.Proxy�c�d��java.lang.reflect.InvocationHandler接口�?

　　Proxy�c�M��要用来获取动态代理对象，InvocationHandler接口用来�U�束调用者实玎ͼ�如下�Q�DiaoSi接口定义�?业务�Ҏ(gu��)��Q�DiaoSiNanImpl是DiaoSi接口的实玎ͼ�
DiaoSiNanHandler�? InvocationHandler接口实现。代码如下：(x��)
业务接口:
package proxy;

public interface DiaoSi {
void luGuan();
}
　业务接口实现�Q?
public class DiaoSiNan implements DiaoSi {

   @Override
   public void luGuan() {
       // TODO Auto-generated method stub
       System.out.println("我是撸管�?);
   }

}
　InvocationHandler实现�Q�需要在接口�Ҏ(gu��)��调用前后加入一部䆾处理工作�Q�这里仅仅在�Ҏ(gu��)��调用前后向后台输��Z��句字�W�串�Q�其代码如下�Q?
package proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class DiaoSiNanHander implements InvocationHandler{
   //要代理的原始对象

private Object diaosinan;
/**

* 构造函数�?br />
* @param obj 要代理的原始对象�?br />
*/
public DiaoSiNanHander(Object diaosinan) {

   this.diaosinan = diaosinan;
}
   @Override

   public Object invoke(Object proxy, Method method, Object[] args)
           throws Throwable {
       // TODO Auto-generated method stub
       Object result ;
       doBefore();
       //调用原始对象的方�?
       result = method.invoke(this.diaosinan ,args);
       //�Ҏ(gu��)��调用之后
       doafter();
       return result;


   }
   private void doafter() {
       // TODO Auto-generated method stub
System.out.println("after method invoke!");
   }
   private void doBefore() {
       // TODO Auto-generated method stub
       System.out.println("before method invoke!");
   }

}
��试代码�Q?
package proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class Test {
public static void main(String[] args) {
DiaoSi ds = new DiaoSiNan();

DiaoSiNanHander handler = new DiaoSiNanHander(ds);

DiaoSi proxy = (DiaoSi) Proxy.newProxyInstance(

ds.getClass().getClassLoader(),

ds.getClass().getInterfaces(),

handler);
/*public static Object newProxyInstance(ClassLoader loader,
        Class[] interfaces,
        InvocationHandler h)
throws IllegalArgumentException
{
if (h == null) {
throw new NullPointerException();
}*/
proxy.luGuan();



}
}
Ø 首先获取一个业务接口的实现对象;

　　Ø 获取一个InvocationHandler实现�Q�此处是
DiaoSiNanHanderHandler对象;

　　Ø 创徏动态代理对�?

　　Ø 通过动态代理对象调用luGuan()�Ҏ(gu��)��Q�此时会(x��)在原始对象DiaoSiNan.luGuan()�Ҏ(gu��)��前后输出两句字符丌Ӏ?

　　�q�行��试�c�输出如�?

　　
before method invoke!
我试撸管�?br />after method invoke!

　　此处Test�c�M��的方法调用代码比较多�Q�在我们的实际应用中可以通过配置文�g来来��化客��L(f��ng)��的调用实现。另外也可以通过动态代理来实现��单的AOP�?

��其自然EVO 2012-12-13 11:53 发表评论

跟屌丝大哥学�?f��n)设计模�?--代理模式

��其自然EVO — Thu, 13 Dec 2012 03:20:00 GMT

Java 代理模式详解
代理模式是我们比较常用的设计模式之一。其中新思想是�ؓ(f��)了提供额外的处理或者不同的操作而在实际对象与调用者之间插入一个代理对象。这些额外的操作通常需要与实际对象�q�行通信�Q�代理模式一般涉及到的角色有�Q?nbsp;

抽象角色�Q�声明真实对象和代理对象的共同接口；

代理角色�Q�代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在�Q何时刻都能代替真实对象。同�Ӟ��代理对象可以在执行真实对象操作时�Q�附加其他的操作�Q�相当于对真实对象进行封装�?nbsp;

真实角色�Q�代理角色所代表的真实对象，是我们最�l�要引用的对象�?

以下以发送消息�ؓ(f��)例来说明一个简单的代理模式的基本实玎ͼ�(x��)

首先明确目的�Q�有一条消息，需要把�q�个消息发送出去，�Ҏ(gu��)��q�个目的定义对应接口MessageHandler。需要的附加操作�Q�假��N��要验证消息的长度不能��过指定长度�q�且不能为空�Q��ƈ且我们需要统计相关信息发送到�ơ数�Q�超�q�指定的�ơ数我们需要输��报。我们通过代理模式来实现这个附加的操作。下面�ؓ(f��)对应的类关系囑֏��C�Z��代码�?/p>

//接口定义
public interface MessageHandler {
public void sendMessage(String msg);
}
//通过Email方式发送消息的实现�c?br />public class EmailMessage implements MessageHandler {
@Override
public void sendMessage(String msg) {
// TODO Auto-generated method stub
System.out.println(msg+" send!!");
}
}
//消息处理的代理类
public class MessageProxy implements MessageHandler {
private static int count;
private MessageHandler emailMsg;
@Override
public void sendMessage(String msg) {
// TODO Auto-generated method stub
if(checkMessage(msg))
{
if(emailMsg==null) emailMsg=new EmailMessage();
count++;
emailMsg.sendMessage(msg);
System.out.println("Message sent:"+count);
}
}
private boolean checkMessage(String msg) {
return msg != null && msg.length() > 10;
}
}
//调用�c?br />public class MainClass {
private static void runProxy(MessageHandler handler)
{
handler.sendMessage("message for test");
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
runProxy(new EmailMessage());
System.out.println("++++++++++++++++Pjroxy++++++++++++++++++");
runProxy(new MessageProxy());
}
}
输出
message for test send!!
++++++++++++++++Pjroxy++++++++++++++++++
message for test send!!
Message sent:1
在例子中我们可以方便的在消息发送过�E�中��d��各种需要的附加处理方式�Q�也能方便的替换消息的处理方式，如将通过Email发送消息替换�ؓ(f��)通过短信发送消息，而调用方不会(x��)有丝毫察觉！在�Q何你惌��一些额外操作分��d��具体对象之外�Q�特别是希望能够很容易做��Z��改，或者想在具体对象的�Ҏ(gu��)��执行前插入一些额外操作的时候，代理��显得十分有用！
　例如�Q�假设有一�l�对象都实现同一个接口，实现同样的方法，但这�l�对象中有一部分对象需要有单独的方法，传统的笨办法是在每一个应用端都加上这个单独的�Ҏ(gu��)��Q�但是代码重用性低�Q�耦合性高�?　　如果用代理的�Ҏ(gu��)��则很好的解决了这个问�?/div>
　假设有一个Italk接口�Q�有�I�的�Ҏ(gu��)��talk�Q�）�Q�说话）�Q�所有的people对象都实玎ͼ�implements�Q�这个接口，实现talk�Q�）�Ҏ(gu��)��Q?前端有很多地斚w��people实例化，执行talk�Ҏ(gu��)��Q�后来发现这些前端里有一些除了要说话以外�q�要唱歌�Q�sing�Q�，那么我们既不能在Italk�?口里增加sing()�Ҏ(gu��)��Q�又不能在每个前端都增加sing�Ҏ(gu��)��Q�我们只有增加一个代理类talkProxy�Q�这个代理类里实现talk和sing�Ҏ(gu��)��Q?然后在需要sing�Ҏ(gu��)��的客��L(f��ng)��调用代理�c�d��可，代码如下�Q?h3>接口�c�Italk　　public interface Italk {
　　public void talk(String msg);
　　}
实现�c�people
　　public class People implements Italk
{ 　　public String username; 　
　public String age; 　
　public String getName()
{ 　　
return username;
　　} 　　
public void setName(String name) {
　　this.username= name; 　　
} 　
　public String getAge() { 　
　return age; 　　} 　　
public void setAge(String age) {
　　this.age = age; 　　} 　
　public People(String name1, String age1) {
　　this.username= name1; 　
　this.age = age1; 　
　}
　　public void talk(String msg) {
　　System.out.println(msg+"!你好,我是"+username+"�Q�我�q�龄�?+age);
　　} 　　
}
代理�c�talkProxy
　　public class TalkProxy implements Italk
{ 　　Italk talker; 　
　public TalkProxy (Italk talker)
{
　　//super(); 　　
this.talker=talker; 　
　} 　　
public void talk(String msg)
{ 　　
talker.talk(msg); 　
　} 　　
public void talk(String msg,String singname)
{ 　　
talker.talk(msg);
　　sing(singname);
　　} 　　
private void sing(String singname)
{ 　
　System.out.println("唱歌�Q?+singname);
　　} 　
　}
　　}
应用端myProxyTest
　　public class MyProxyTest { 　
　/**代理模式　　* @param args 　　*/ 　
　public static void main(String[] args)
{ 　　
//不需要执行额外方法的　
　Italk people1=new People("　people1.talk("No ProXY Test"); 　
　System.out.println("-----------------------------"); 　
　//需要执行额外方法的　　
TalkProxy talker=new TalkProxy(people1); 　　
talker.talk("ProXY Test","七里�?);
　　} 　
　}
所谓代理，是指��h��与代理元�Q�被代理的对象）��h��相同的接口的�c�，客户端必��通过代理与被�?理的目标�c�M��互，而代理一般在交互的过�E�中�Q�交互前后）�Q�进行某些特别的处理。Proxy模式是很常见的模式，在我们生�z�M��处处可见�Q�例如我们买火�R��不一定非要到火�R站去乎ͼ�可以��C��些火车票的代售点��M��。寄信不一定是自己��d��Q�可以把信委托给邮局�Q�由邮局把信送到目的地�?
代理�l�构如下图所�C?/p>

以通过代售点买火�R��ؓ(f��)例，代码实现如下�Q?/p>
//提供买票的公共接�?br />interface Passenger {
public void buyTicket();
}

//乘客实体
public class RealPassenger implements Passenger {
@Override
public void buyTicket() {
   // TODO Auto-generated method stub
   System.out.print("购买了火车票");
}
}

//代售�?br />public class Proxy implements Passenger {
Passenger passenger;

public Proxy(Passenger p) {
   this.passenger = p;
}

@Override
public void buyTicket() {
   // TODO Auto-generated method stub
   System.out.println("通过代售�?);
   passenger.buyTicket();
}
}

//��试�c?br />public class Client {
public static void main(String[] args) {
   Passenger passenger = new RealPassenger();
   Passenger proxy = new Proxy(passenger);
   proxy.buyTicket();
}
}

输出�l�果�Q?br />通过代售�?br />购买了火车票

�?上的也可叫做静态代理，是�ؓ(f��)了区别代理模式在Java中的另一�U�实�?#8212;—动态代理�?/p>
接下来会(x��)为大家带来动态代�?br />

��其自然EVO 2012-12-13 11:20 发表评论

��其自然EVO — Wed, 12 Dec 2012 05:23:00 GMT
     摘要: 中介者模式（Mediator�Q�：(x��)用一个中介对象来��装一�p�d��的对象交互。中介者��各对象不需要显式地�怺�引用�Q�从而��其耦合松散�Q�而且可以独立地改变它们之间的交互。通用�c�d��Q��D例：(x��)在一个公叔R��面，有很多部门、员工（我们�l�称他们互相为Colleague“同事”�Q�，��Z��完成一定的��d��Q?#8220;同事”之间肯定有许多需要互盔R��合、交��的�q�程。如果由各个“同事...  阅读全文

��其自然EVO 2012-12-12 13:23 发表评论

��其自然EVO — Tue, 11 Dec 2012 03:51:00 GMT

Java　观察者模式的��析
��单地��_(d��)��观察者模式定义了一个一对多的依赖关�p�，让一个或多个观察者对象监察一个主题对象。这样一个主题对象在状态上的变化能够通知所有的依赖于此对象的那些观察者对象，使这些观察者对象能够自动更新�?br />　观察者模式的�l�构

　　观察者（Observer�Q�模式是对象的行为型模式�Q�又叫做发表-订阅�Q�Publish/Subscribe�Q�模式、模�?视图�Q�Model/View�Q�模式、源-收听者（Source/Listener�Q�模式或从属者（Dependents�Q�模式�?br />
　本模式的�c�d��l�构如下�Q?br />

�?、观察者模式的静态结构可从类图中看清楚�?/td>
　　在观察者模式里有如下的角色�Q?br />　. 抽象主题�Q�Subject�Q�角�?/strong>�Q�主题角色把所有的观察者对象的引用保存在一个列表里�Q�每个主题都可以有�Q何数量的观察者。主题提供一个接口可以加上或撤销观察者对象；主题角色又叫做抽象被观察�?Observable)角色�Q?nbsp;

�?、抽象主题角�Ԍ��有时又叫做抽象被观察者角�Ԍ��可以用一个抽象类或者一个接口实玎ͼ�在具体的情况下也不排除��用具体类实现�?/td>
　　. 抽象观察者（Observer�Q�角�?/strong>�Q��ؓ(f��)所有的具体观察者定义一个接口，在得到通知时更新自己；

�?、抽象观察者角�Ԍ��可以用一个抽象类或者一个接口实玎ͼ�在具体的情况下也不排除��用具体类实现�?/td>
　　. 具体主题�Q�ConcreteSubject�Q�角�?/strong>�Q�保存对具体观察者对象有用的内部状态；在这�U�内部状态改变时�l�其观察者发��Z��个通知�Q�具体主题角色又叫作具体被观察者角�Ԍ��

�?、具体主题角�Ԍ��通常用一个具体子�c�d��现�?br />
�Q?strong>具体观察者（ConcreteObserver�Q�角�?/strong>�Q�保存一个指向具体主题对象的引用�Q�和一个与主题的状态相�W�的状态。具体观察者角色实现抽象观察者角色所要求的更新自��q��接口�Q�以便��本��n的状态与主题的状态自恰�?nbsp;

�?、具体观察者角�Ԍ��通常用一个具体子�c�d��现�?/td>

下面�l�出一个示意性实现的Java代码。首先在�q�个�C�意性的实现里，用一个Java接口实现抽象主题角色�Q�这��是下面的Subject接口�Q?br />

public interface Subject
{
public void attach(Observer observer);

public void detach(Observer observer);

void notifyObservers();
}
代码清单1、Subject接口的源代码�?nbsp;

　　�q�个抽象主题接口规定��Z��个子�c�d��d��现的操作�Q�即 attach() 用来增加一个观察者对象；detach() 用来删除一个观察者对象；和notifyObservers() 用来通知各个观察者刷新它们自己。抽象主题角色实际上要求子类保持一个以所有的观察者对象�ؓ(f��)元素的列表�?br />
　　具体主题则是实现了抽象主题Subject接口的一个具体类�Q�它�l�出了以上的三个操作的具体实现。从下面的源代码可以看出�Q�这里给出的Java实现使用了一个Java向量来保存所有的观察者对象，�?attach() �?detach() 操作则是�Ҏ(gu��)��向量的元素增减操作�?br />

import java.util.Vector;
import java.util.Enumeration;

public class ConcreteSubject implements Subject
{
public void attach(Observer observer)
{
observersVector.addElement(observer);
}

public void detach(Observer observer)
{
observersVector.removeElement(observer);
}

public void notifyObservers()
{
Enumeration enumeration = observers();
while (enumeration.hasMoreElements())
{
((Observer)enumeration.nextElement()).update();
}
}

public Enumeration observers()
{
return (�Q�Vector) observersVector.clone()).elements();
}
private Vector observersVector = new java.util.Vector();
}
代码清单2、ConcreteSubject�cȝ��源代码�?nbsp;
　　抽象观察者角色的实现实际上是最为简单的一个，它是一个Java接口�Q�只声明了一个方法，即update()。这个方法被子类实现后，一被调用便��h��自己�?br />
public interface Observer
{
void update();
}
代码清单3、Observer接口的源代码�?nbsp;

　　具体观察者角色的实现其实只涉及update()�Ҏ(gu��)��的实现。这个方法怎么实现与应用密切相养I��因此本类只给��Z��个框架�?br />
public class ConcreteObserver implements Observer
{
public void update()
{
// Write your code here
}
}
代码清单4、ConcreteObserver�cȝ��源代码�?nbsp;

　　虽然观察者模式的实现�Ҏ(gu��)��可以有设计师自己��定�Q�但是因��Z��AWT1.1开始视�H�系�l�的事�g模型采用观察者模式，因此观察者模式在Java语言里的��C��较�ؓ(f��)重要。正因�ؓ(f��)�q�个原因�Q�Java语言�l�出了它自己对观察者模式的支持。因此，本文��读者在自己的系�l�中应用观察者模式时�Q�不妨利用Java语言所提供的支持�?br />　　Java语言提供的对观察者模式的支持

　　在Java语言的java.util库里面，提供了一个Observable�c�M��及一个Observer接口�Q�构成Java语言对观察者模式的支持�?br />
　　Observer接口

　　�q�个接口只定义了一个方法，update()。当被观察者对象的状态发生变化时�Q�这个方法就�?x��)被调用。这个方法的实现应当调用每一个被观察者对象的notifyObservers()�Ҏ(gu��)��Q�从而通知所有的观察对象�?br />

�?、java.util提供的Observer接口的类图�?/td>

package java.util;

public interface Observer
{
/**
* 当被观察的对象发生变化时�Q�这个方法会(x��)被调用�?br />*/
void update(Observable o, Object arg);
}
代码清单5、java.util.Observer接口的源代码�?nbsp;

　　Observable�c?/strong>

　　被观察者类都是java.util.Observable�cȝ��子类。java.util.Observable提供公开的方法支持观察者对象，�q�些�Ҏ(gu��)��中有两个对Observable的子�c�非帔R��要：(x��)一个是setChanged()�Q�另一个是notifyObservers()。第一个方法setChanged()被调用之后会(x��)讄��一个内部标记变量，代表被观察者对象的状态发生了变化。第二个是notifyObservers()�Q�这个方法被调用�Ӟ��?x��)调用所有登记过的观察者对象的update()�Ҏ(gu��)��Q��ɘq�些观察者对象可以更新自己�?br />
　　java.util.Observable�c�还有其它的一些重要的�Ҏ(gu��)��。比如，观察者对象可以调用java.util.Observable�cȝ��addObserver()�Ҏ(gu��)��Q�将对象一个一个加入到一个列表上。当有变化时�Q�这个列表可以告诉notifyObservers()�Ҏ(gu��)��那些观察者对象需要通知。由于这个列表是�U�有的，因此java.util.Observable的子对象�q�不知道观察者对象一直在观察着它们�?br />

�?、Java语言提供的被观察者的�c�d��?/td>

　　被观察者类Observable的源代码�Q?br />
package java.util;
public class Observable
{
private boolean changed = false;
private Vector obs;

/** �?个观察者构造一个被观察者�?*/

public Observable()
{
obs = new Vector();
}

/**
* ��一个观察者加到观察者列表上面�?br />*/
public synchronized void addObserver(Observer o)
{
if (!obs.contains(o))
{
obs.addElement(o);
}
}

/**
* ��一个观察者对象从观察者列表上删除�?br />*/
public synchronized void deleteObserver(Observer o)
{
obs.removeElement(o);
}

/**
* 相当�?nbsp;notifyObservers(null)
*/
public void notifyObservers()
{
notifyObservers(null);
}

/**
* 如果本对象有变化�Q�那时hasChanged �Ҏ(gu��)��?x��)返回true�Q?br />* 调用本方法通知所有登记在案的观察者，卌��用它们的update()�Ҏ(gu��)��Q?br />* 传入this和arg作�ؓ(f��)参量�?br />*/
public void notifyObservers(Object arg)
{
/**
* 临时存放当前的观察者的状态。参见备忘录模式�?br />*/
Object[] arrLocal;

synchronized (this)
{
if (!changed) return;
arrLocal = obs.toArray();
clearChanged();
}

for (int i = arrLocal.length-1; i>=0; i--)
((Observer)arrLocal[i]).update(this, arg);
}

/**
* ��观察者列表清�I?br />*/
public synchronized void deleteObservers()
{
obs.removeAllElements();
}

/**
* ��?#8220;已变�?#8221;设�ؓ(f��)true
*/
protected synchronized void setChanged()
{
changed = true;
}

/**
* ��?#8220;已变�?#8221;重置为false
*/
protected synchronized void clearChanged()
{
changed = false;
}

/**
* 探测本对象是否已变化
*/
public synchronized boolean hasChanged()
{
return changed;
}

/**
* �q�还被观察对象（��x��对象�Q�的观察者��L��?br />*/
public synchronized int countObservers()
{
return obs.size();
}
}

代码清单6、java.util.Observer接口的源代码�?nbsp;

　　�q�个Observable�c�M��表一个被观察者对象。一个被观察者对象可以有��C��观察者对象，一个观察者可以是一个实现Observer接口的对象。在被观察者对象发生变化时�Q�它�?x��)调用Observable的notifyObservers�Ҏ(gu��)��Q�此�Ҏ(gu��)��调用所有的具体观察者的update()�Ҏ(gu��)��Q�从而��所有的观察者都被通知更新自己。见下面的类图：(x��)

�?、��用Java语言提供的对观察者模式的支持�?/td>

　　发通知的次序在�q�里没有指明。Observerable�c�L��提供的缺省实��C��(x��)按照Observers对象被登记的�ơ序通知它们�Q�但是Observerable�cȝ��子类可以�Ҏ(gu��)��q�一�ơ序。子�c�dƈ可以在单独的�U�程里通知观察者对象；或者在一个公用的�U�程里按照次序执行�?nbsp;

　　当一个可观察者对象刚刚创立时�Q�它的观察者集合是�I�的。两个观察者对象在它们的equals()�Ҏ(gu��)��q�回true�Ӟ��被认为是两个相等的对象�?nbsp;
　　怎样使用Java对观察者模式的支持

　　��Z��说明怎样使用Java所提供的对观察者模式的支持�Q�本节给��Z��个非常简单的例子。在�q�个例子里，被观察对象叫做Watched�Q�也��是被监视者；而观察者对象叫做Watcher。Watched对象�l�承自java.util.Obsevable�c�；而W(xu��)atcher对象实现了java.util.Observer接口。另外有一个对象Tester�Q�扮演客��L(f��ng)��的角艌Ӏ?nbsp;

　　�q�个��单的�pȝ��的结构如下图所�C��?nbsp;

�?、一个��用Observer接口和Observable�cȝ��例子�?/td>

　　在客��L(f��ng)��改变Watched对象的内部状态时�Q�W(xu��)atched��׃��(x��)通知Watcher采取必要的行动�?nbsp;

package com.javapatterns.observer.watching;

import java.util.Observer;

public class Tester
{
static private Watched watched;
static private Observer watcher;

public static void main(String[] args)
{
watched = new Watched();

watcher = new Watcher(watched);

watched.changeData("In C, we create bugs.");
watched.changeData("In Java, we inherit bugs.");
watched.changeData("In Java, we inherit bugs.");
watched.changeData("In Visual Basic, we visualize bugs.");
}
}

　　代码清单7、Tester�cȝ��源代码�?nbsp;

　代码清单7、Tester�cȝ��源代码�?nbsp;

package com.javapatterns.observer.watching;

import java.util.Observable;

public class Watched extends Observable
{
private String data = "";

public String retrieveData()
{
return data;
}

public void changeData(String data)
{
if ( !this.data.equals( data) )
{
this.data = data;
setChanged();
}

notifyObservers();
}
}

代码清单9、Watcher�cȝ��源代码�?nbsp;

　　可以看出�Q�虽然客��L(f��ng)��Watched对象的内部状态赋��g��四次�Q�但是值的改变只有三次�Q?br />
watched.changeData("In C, we create bugs.");
watched.changeData("In Java, we inherit bugs.");
watched.changeData("In Java, we inherit bugs.");
watched.changeData("In Visual Basic, we visualize bugs.");

　　代码清单10、被观察者的内部状态发生了改变�?nbsp;

　　对应圎ͼ�W(xu��)atcher对象汇报了三�ơ改变，下面��是�q�行旉��E�序打印出的信息�Q?br />

Data has been changed to: 'In C, we create bugs.'

Data has been changed to: 'In Java, we inherit bugs.'

Data has been changed to: 'In Visual Basic, we visualize bugs.'

　　代码清单11、运行的�l�果�?nbsp;

　菩萨的守瓉��

　　惛_��q�齐天大圣�ؓ(f��)解救师傅唐僧�Q�前往南�v普陀��p��菩萨降伏妖怪红孩儿�Q?#8220;菩萨听说...恨了一壎ͼ��手中宝珠净瓶往��心里扑的一�?..只见那�v当中�Q�翻波蟩��，��d��个瓶来，原来是一个怪物驮着出来...要知此怪名和姓�Q�兴风作��恶乌龟�?#8221;

　　使用面向对象的语�a�描述�Q�乌龟便是一个观察者对象，它观察的主题是菩萨。一旦菩萨将净瓶掼到�v里，��p��征着菩萨作�ؓ(f��)主题调用了notifyObservers()�Ҏ(gu��)��。在西游��C��Q�观察者对象有两个�Q�一个是乌龟�Q�另一个是�(zh��n)�空。�?zh��n)��I�的反应在这里暂时不考虑�Q�而乌龟的反应便是��瓶子驮回�v岸�?nbsp;

�?0、菩萨和菩萨的守瓶乌龟�?/td>
Java中的DEM事�g机制

　　AWT中的DEM机制

　　责�Q链模式一章中曾谈刎ͼ�AWT1.0的事件处理的模型是基于责任链的。这�U�模型不适用于复杂的�pȝ��Q�因此在AWT1.1版本及以后的各个版本中，事�g处理模型均�ؓ(f��)��Z��观察者模式的委派事�g模型�Q�Delegation Event Model或DEM�Q��?nbsp;

　　在DEM模型里面�Q�主题（Subject�Q�角色负责发布（publish�Q�事�Ӟ��而观察者角色向特定的主题订阅（subscribe�Q�它所感兴��的事�g。当一个具体主题��生一个事件时�Q�它?y��u)�׃�?x��)通知所有感兴趣的订阅者�?nbsp;

　　使用�q�种发布-订阅机制的基本设计目标，是提供一�U�将发布者与订阅者松散地耦合在一��L(f��ng)��联系形式�Q�以及一�U�能够动态地登记、取消向一个发布者的订阅��h��的办法。显�Ӟ��实现�q�一构思的技巧，是设计抽象接口，�q�把抽象层和具体层分开。这在观察者模式里可以清楚地看到�?nbsp;

　　使用DEM的用词，发布者叫做事件源�Q�event source�Q�，而订阅者叫做事件聆听者（event listener�Q�。在Java里面�Q�事件由�c�M��表，事�g的发布是通过同步地调用成员方法做到的�?nbsp;

　　Servlet技术中的的DEM机制

　　AWT中所使用的DEM事�g模型实际上被应用��C��所有的Java事�g机制上。Servlet技术中的事件处理机制同样也是��用的DEM模型�?nbsp;

　　SAX2技术中的DEM机制

　　DEM事�g模型也被应用��C��SAX2的事件处理机制上�?nbsp;

　　观察者模式的效果

　　观察者模式的效果有以下的优点�Q?nbsp;

　　�W�一、观察者模式在被观察者和观察者之间徏立一个抽象的耦合。被观察者角色所知道的只是一个具体观察者列表，每一个具体观察者都�W�合一个抽象观察者的接口。被观察者�ƈ不认识�Q何一个具体观察者，它只知道它们都有一个共同的接口�?nbsp;

　　�׃��被观察者和观察者没有紧密地耦合在一��P��因此它们可以属于不同的抽象化层次。如果被观察者和观察者都被扔��C��P��那么�q�个对象必然跨越抽象化和具体化层�ơ�?nbsp;

　　�W�二、观察者模式支持广播通讯。被观察者会(x��)向所有的登记�q�的观察者发出通知�Q?nbsp;

　　观察者模式有下面�?strong>�~�点�Q?nbsp;

　　�W�一、如果一个被观察者对象有很多的直接和间接的观察者的话，��所有的观察者都通知��C��(x��)��p��很多旉��?nbsp;

　　�W�二、如果在被观察者之间有循环依赖的话�Q�被观察者会(x��)触发它们之间�q�行循环调用�Q�导致系�l�崩溃。在使用观察者模式是要特别注意这一炏V�?nbsp;

　　�W�三、如果对观察者的通知是通过另外的线�E�进行异步投递的话，�pȝ��必须保证投递是以自恰的方式�q�行的�?nbsp;

　　�W�四、虽然观察者模式可以随时��观察者知道所观察的对象发生了变化�Q�但是观察者模式没有相应的机制使观察者知道所观察的对象是怎么发生变化的�?nbsp;

　　观察者模式与其它模式的关�p?/strong>

　　观察者模式��用了备忘录模�?Memento Pattern)暂时��观察者对象存储在被观察者对象里面�?br />
　　问答�?/strong>

　　�W�一题、我和妹妹跟妈妈��_(d��)��(x��)“妈妈�Q�我和妹妹在院子里玩�Q�饭做好了叫我们一声�?#8221;请问�q�是什么模式？能否�l�出�c�d��说明�Q?br />
　　问答题答�?/strong>

　　�W�一题答案、这是观察者模式。我和妹妹让妈妈告诉我们饭做好了�Q�这��h��们就可以来吃饭了。换用较为技术化的语�a�来说�Q�当�pȝ��的主题（饭）发生变化�Ӟ��告诉系�l�的其它部䆾�Q�观察者们�Q�也��是妈妈、我和妹妹）�Q��其可以调整内部状态（有开始吃饭的准备�Q�，�q��取相应的行动�Q�吃饭）�?br />
　　�pȝ��的类图说明如下�?br />

�?1、系�l�的�c�d��?/td>

�|�上商店中的商品在名�U�、�h(hu��n)格发生变化时�Q�必��自动通知�?x��)员�Q�Java的API为我们提供了Observer接口和Observable�c�L��实现所谓观察者模式�?br />Observable(可观察者）�c�d��许在自��n发生改变�Ӟ��通知其它对象�Q�实现接口Observer�Q�观察者）�?/p>
下面是一个可观察者（产品�c�）�Q?br />import java.util.*;
public class product extends Observable{
　　 private String name;////产品�?br />　　 private float price;////��h��
　　 public String getName(){ return name;}
　　 public void setName(String name){
　　 this.name=name;
　　 ////讄��变化�?nbsp;
　　 setChanged();
　　 notifyObservers(name);////通知观察�?/p>
　　 }　　　
　　 public float getPrice(){ return price;}
　　 public void setPrice(float price){
　　 this.price=price;
　　 ////讄��变化�?br />　　 setChanged();
　　 notifyObservers(new Float(price));
　　 }
　　 ////以下可以是数据库更新插入命��o.
　　 public void saveToDb(){
　　 System.out.println("saveToDb");
    }
}
下面是两个观察者：(x��)
import java.util.*;
public class NameObserver implements Observer{
　　 private String name=null;
　　 public void update(Observable obj,Object arg){
　　　　 if (arg instanceof String){
　　　　 name=(String)arg;
　　　　 ////产品名称改变值在name�?br />　　　　 System.out.println("NameObserver :name changet to "+name);
　　　　 }
      }
　　 }
import java.util.*;
public class PriceObserver implements Observer{
　　 private float price=0;
　　 public void update(Observable obj,Object arg){
　　　　 if (arg instanceof Float){
　　　　 price=((Float)arg).floatValue();
　　
　　　　 System.out.println("PriceObserver :price changet to "+price);
　　　　 }

　　 }
}
下面是测试类�Q?br />public class Test {
　　 public static void main(String args[]){
    Product product=new Product();
    NameObserver nameobs=new NameObserver();
    PriceObserver priceobs=new PriceObserver();
    ////加入观察�?br />    product.addObserver(nameobs);
    product.addObserver(priceobs);
    product.setName("applet");
    product.setPrice(9.22f);
　　 }
}

��其自然EVO 2012-12-11 11:51 发表评论

跟屌丝大哥学设计模式-单例模式

��其自然EVO — Fri, 07 Dec 2012 06:55:00 GMT
概念�Q?/span>
　　java中单例模式是一�U�常见的设计模式�Q?/span>单例模式分三�U�：(x��)懒汉式单例、饿汉式单例、登记式单例三种�?br />哈哈我们可以�q�样�?屌丝单例模式�Q�懒汉式屌丝单例�Q�饿汉式屌丝单例�Q�登记式屌丝单例�?br />
　　单例模式有一下特点：(x��)
　　1、单例类只能有一个实例�?span style="margin: 0px; padding: 0px;">
　　2、单例类必须自己自己创徏自己的唯一实例�?span style="margin: 0px; padding: 0px;">
　　3、单例类必须�l�所有其他对象提供这一实例�?br />
单例模式��保某个�c�d��有一个实例，而且自行实例化�ƈ向整个系�l�提供这个实例�?/span>在计��机�pȝ��中，�U�程池、缓存、日志对象、对话框、打印机、显卡的驱动�E�序对象常被设计成单例。这些应用都或多或少��h��资源��理器的功能。每台计��机可以有若�q�个打印机，但只能有一�?/span>Printer Spooler�Q�以避免两个打印作业同时输出到打印机中。每台计��机可以有若�q�通信端口�Q�系�l�应当集中管理这些通信端口�Q�以避免一个通信端口同时被两个请求同时调用。��M��Q�选择单例模式��是��Z��避免不一致状态，避免政出多头�?/span>
首先看一个经典的单例实现�?br />
public class Singleton {
    private static Singleton uniqueInstance = null;

    private Singleton() {
       // Exists only to defeat instantiation.
    }

    public static Singleton getInstance() {
       if (uniqueInstance == null) {
           uniqueInstance = new Singleton();
       }
       return uniqueInstance;
    }
    // Other methods...
}
Singleton通过��构造方法限定�ؓ(f��)private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()�Ҏ(gu��)��讉K��。（事实上，通过Java反射机制是能够实例化构造方法�ؓ(f��)private的类的，那基本上�?x��)��所有的Java单例实现失效�?/strong>此问题在此处不做讨论�Q�姑且掩耳盗铃地认�ؓ(f��)反射机制不存在。）
但是以上实现没有考虑�U�程安全问题。所谓线�E�安全是指：(x��)如果你的代码所在的�q�程中有多个�U�程在同时运行，而这些线�E�可能会(x��)同时�q�行�q�段代码。如果每�ơ运行结果和单线�E�运行的�l�果是一��L(f��ng)��Q�而且其他的变量的��g��和预期的是一��L(f��ng)��Q�就是线�E�安全的。或者说�Q�一个类或者程序所提供的接口对于线�E�来说是原子操作或者多个线�E�之间的切换不会(x��)��D��该接口的执行�l�果存在二义�?/span>,也就是说我们不用考虑同步的问题。显然以上实现�ƈ不满��线�E�安全的要求�Q�在�q�发环境下很可能出现多个Singleton实例�?br />
public class TestDiaoSiStream {
private String DiaoSiname;
public String getDiaoSiname() {
return DiaoSiname;
}
public void setDiaoSiname(String DiaoSiname) {
this.DiaoSiname = DiaoSiname;
}
//该类只能有一个实�?/div>
private TestDiaoSiStream(){} //�U�有无参构造方�?/div>
//该类必须自行创徏
//�?�U�方�?/div>
/*private static final TestDiaoSiStream ds=new TestDiaoSiStream();*/
private static TestDiaoSiStream ds1=null;
//�q�个�c�d��自动向整个�pȝ��提供�q�个实例对象
public static TestDiaoSiStream getTestDiaoSiTest(){
if(ds1==null){
ds1=new TestDiaoSiStream();
}
return ds1;
}
public void getInfo(){
System.out.println("output message "+DiaoSiname);
}
}

public class TestMain {
public static void main(String [] args){
TestDiaoSiStream ds=TestDiaoSiStream.getTestDiaoSiTest();
ds.setDiaoSiname("奶娃");
System.out.println(ds.getDiaoSiname());
TestDiaoSiStream ds1=TestDiaoSiStream.getTestDiaoSiTest();
ds1.setDiaoSiname("奶娃");
System.out.println(ds1.getDiaoSiname());
ds.getInfo();
ds1.getInfo();
if(ds==ds1){
System.out.println("创徏的是同一个屌丝实�?);
}else if(ds!=ds1){
System.out.println("创徏的不是同一个屌丝实�?);
}else{
System.out.println("application error");
}
}
}
�q�行�l�果�Q?br style="margin: 0px; padding: 0px;" />　　奶娃
　　奶娃
　　output message 奶娃
　　output message 奶娃
　　创徏的是同一�?span style="color: #000000; font-family: 宋体; line-height: 20.066667556762695px; text-indent: 28px;">屌丝
实例
�l�论�Q�由�l�果可以得知单例模式��Z��个面向对象的应用�E�序提供了对象惟一的访问点�Q�不��它实现何种功能�Q?span style="margin: 0px; padding: 0px; color: #800000;">整个应用�E�序都会(x��)同��n一个实例对�?/span>�?/span>
1.饿汉式单例类

//饿汉式单例类.在类初始化时�Q�已�l�自行实例化
public class Singleton1 {
//�U�有的默认构造子
private Singleton1() {}
//已经自行实例�?nbsp;
private static final Singleton1 single = new Singleton1();
//静态工厂方�?nbsp;
public static Singleton1 getInstance() {
return single;
}
}

2.懒汉式单例类
//懒汉式单例类.在第一�ơ调用的时候实例化
public class Singleton2 {
//�U�有的默认构造子
private Singleton2() {}
//注意�Q�这里没有final
private static Singleton2 single=null;
//静态工厂方�?nbsp;
public synchronized static Singleton2 getInstance() {
if (single == null) {
single = new Singleton2();
}
return single;
}
}
3.登记式单例类

import java.util.HashMap;
import java.util.Map;
//登记式单例类.
//�c�M��Spring里面的方法，��类名注册，下次从里面直接获取�?/div>
public class Singleton3 {
private static Map map = new HashMap();
static{
Singleton3 single = new Singleton3();
map.put(single.getClass().getName(), single);
}
//保护的默认构造子
protected Singleton3(){}
//静态工厂方�?�q�还此类惟一的实�?/div>
public static Singleton3 getInstance(String name) {
if(name == null) {
name = Singleton3.class.getName();
System.out.println("name == null"+"--->name="+name);
}
if(map.get(name) == null) {
try {
map.put(name, (Singleton3) Class.forName(name).newInstance());
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
return map.get(name);
}
//一个示意性的商业�Ҏ(gu��)��
public String about() {
return "Hello, I am RegSingleton.";
}
public static void main(String[] args) {
Singleton3 single3 = Singleton3.getInstance(null);
System.out.println(single3.about());
}
}

��其自然EVO 2012-12-07 14:55 发表评论

跟屌丝学设计模式之责任链模式

��其自然EVO — Thu, 06 Dec 2012 03:19:00 GMT
     摘要: JAVA之责任链模式原文地址�Q�http://itzyx.com/index.php/java_zrl/在阎宏博士的《JAVA与模式》一书中开头是�q�样描述责�Q链（Chain of Responsibility�Q�模式的�Q?nbsp;　　责�Q链模式是一�U�对象的行�ؓ(f��)模式。在责�Q链模式里�Q�很多对象由每一个对象对其下家的引用而连接�v来�Ş成一条链。请求在�q�个链上传递，直到链上的某一个对象决�?..  阅读全文

��其自然EVO 2012-12-06 11:19 发表评论

java设计模式-桥接模式�Q�屌丝男学设计模式）

��其自然EVO — Wed, 05 Dec 2012 08:21:00 GMT

本文介绍设计模式中的桥接�Q?a target="_self" style="color: #336699; text-decoration: initial;">Bridge�Q�模式的概念�Q�用法，以及实际应用中怎么样��?a target="_self" style="color: #336699; text-decoration: initial;">桥接模式�q�行开发�?/span>
Bridge模式的概�?/strong>
Bridge 模式是构造型的设计模式之一。Bridge模式��Z��cȝ��最��设计原则，通过使用��装�Q�聚合以及��承等行�ؓ(f��)来让不同的类承担不同的责仅R��它的主要特�Ҏ(gu��)��把抽象（abstraction�Q�与行�ؓ(f��)实现�Q�implementation�Q�分��d��来，从而可以保持各部分的独立性以及应对它们的功能扩展�?br />
Bridge模式的应用场�?/strong>
面向对象的程序设计（OOP�Q�里有类�l�承�Q�子�cȝ��承父�c�）的概念，如果一个类或接口有多个具体实现子类�Q�如果这些子�c�d��有以下特性：(x��)
- 存在相对�q�列的子�c�d��性�?br />- 存在概念上的交叉�?br />- 可变性�?br />我们��可以用Bridge模式来对其进行抽象与具体�Q�对相关�c�进行重构�?br />
��Z��Ҏ(gu��)��理解�Q�我们�D例说明一下，比如屌丝�Q�DiaoSi�Q�，假设�?个子�c�，男屌丝类�Q�ManDiaoSi�Q�与奛_��丝类�Q�WomanDiao�Q�，它们有[�I�h��矮]�q�个动作行�ؓ(f��)�Q�通过不同�I�h��矮特征的讄��Q�可以将它们讄��为比如�ؓ(f��)拥有黑木耳男屌丝或（拥有撸管王的奛_��丝）�Q�和拥有紫木耳男屌丝或（拥有撸神的女屌丝�Q�的各种屌丝�?br />�q�样�Q�不��是黑木耳男屌丝�q�是紫木耳男屌丝�Q�又或是有撸��王的女屌丝�q�是有撸��的奛_��丝，它们都可以是屌丝�cȝ��子类�Q�而且�Q?br />- 存在相对�q�列的子�c�d��性。屌丝的�U�类�Q�与屌丝�I�h��矮的规格是屌丝的2个�ƈ列的属性，没有概念上的重复�?br />- 存在概念上的交叉。不��是男屌丝还是女屌丝�Q�都是穷挫矮�Q�黑�I�丑的屌丝�?br />- 可变性。除了男屌丝�Q�女屌丝之外�Q�可能还有�h妖屌丝；除了有黑木耻I��撸管王）与��木耻I��撸神�Q�特征的屌丝之外�Q�还可能有��黑木耻I��撸圣�Q�的屌丝�{�等�?/p>
�q�样一来，我们怎么来设计屌丝类呢？

�Ҏ(gu��)��一
通过�l�承设计所有可能存在的子类。可能我们会(x��)惛_��下面的这�U��承关�p�：(x��)
屌丝�ȝ��Q�DiaoSi
屌丝子类 - 按种�c�d��c�：(x��)ManDiaoSi�Q?span style="color: #000000; font-family: verdana, 'courier new'; line-height: 21px;">WomanDiao
屌丝子类 - 按特征分�c�：(x��)拥有黑木耳男屌丝�Q�拥�?span style="color: #000000; font-family: verdana, 'courier new'; line-height: 21px;">撸管王的奛_��?/span>�Q?span style="color: #000000; font-family: verdana, 'courier new'; line-height: 21px;">拥有紫木耳男屌丝�Q?span style="color: #000000; font-family: verdana, 'courier new'; line-height: 21px;">拥有撸神的女屌丝
�q�样讄��特征�q�个动作��q��各个子类加以实现�?/p>
但如果以后需要增加一�U?span style="color: #000000; font-family: verdana, 'courier new'; line-height: 21px;">人妖屌丝�Q�GuyDiaoSi�Q�，以及增加一个特征规格��黑木耻I��需要实现的子类��会(x��)有：(x��)
拥有黑木耳男屌丝�Q�拥�?span style="color: #000000; font-family: verdana, 'courier new'; line-height: 21px;">撸管王的奛_��?/span>�Q?span style="color: #000000; font-family: verdana, 'courier new'; line-height: 21px;">拥有紫木耳男屌丝�Q?span style="color: #000000; font-family: verdana, 'courier new'; line-height: 21px;">拥有撸神的女屌丝拥有紫黑木耳男屌丝拥有撸管王的人妖屌丝拥有紫黑木耳�h妖屌�?nbsp;拥有紫木耳�h妖屌�?/span>
�{�等�?br />也就是说�Q�这�U�设计方法，子类数目��随几何�U�数增长�?br />而且�Q?span style="color: #000000; font-family: verdana, 'courier new'; line-height: 21px;">拥有黑木耳男屌丝�Q?span style="color: #000000; font-family: verdana, 'courier new'; line-height: 21px;">拥有紫木耳�h妖屌�?/span>的特征规格相同，它们的特征设�|�动作应该是一��L(f��ng)��Q�但现在把它们分成不同的子类�Q�难以避免执行重复的动作行�ؓ(f��)�?/p>

�Ҏ(gu��)��?/strong>
分别为男屌丝以及奛_��丝实现设�|�不同特征的�Ҏ(gu��)��
屌丝�ȝ��Q�DiaoSi
屌丝子类�Q?span style="color: #000000; font-family: verdana, 'courier new'; line-height: 21px;">ManDiaoSi�Q?span style="color: #000000; font-family: verdana, 'courier new'; line-height: 21px;">WomanDiao
然后在男屌丝�c�里分别提供黑木耻I��撸管王）以及紫木耻I��撸神�Q�特征的讄��Ҏ(gu��)��Q?br />ManDiaoSi extends DiaoSi
{
    public setFeatures黑木�?);
    public setFeatures紫木�?);
}
在女屌丝�c�里也分别提供撸��王以及撸神特征的设�|�方法：(x��)
WomanDiao extends DiaoSi
{
    public setFeatures撸管�?);
    public setFeatures撸神();
}

�q�种情况�Q�子�cȝ��数量是被控制了。但一斚w��Q�如果每增加一�U�特征规��|��需要修�Ҏ(gu��)��有的屌丝子类�Q�另一斚w��Q�即使特征的讄��行�ؓ(f��)一��P��但是不同的屌丝子�c�d��需要提供完全一��L(f��ng)��Ҏ(gu��)��?br />
在实际的应用开发中�Q�以�?�U�方法都�?x��)造成�q�一发而动全��n�Q�而且�?x��)存在大量的重复代码�?/p>
Bridge模式可以很好的解册��c�问题�?br />Client
    Bridge模式的��用�?br />Abstraction
    抽象�c�L��口（接口或抽象类�Q?br />    �l�护对行为实玎ͼ�Implementor�Q�的引用
Refined Abstraction
    Abstraction子类
Implementor
    行�ؓ(f��)实现�c�L��?(Abstraction接口定义了基于Implementor接口的更高层�ơ的操作)
ConcreteImplementor
    Implementor子类

Bridge模式的应用范�?/strong>
我们来看看怎么应用Bridge模式来设计汽车类�?/p>
抽象 - Abstraction�c�：(x��)屌丝�c�d��其子�c�：(x��)
屌丝�ȝ��Q�DiaoSi
屌丝子类 - 按种�c�d��c�：(x��)ManDiaoSi�Q?span style="color: #000000; font-family: verdana, 'courier new'; line-height: 21px;">WomanDiao
屌丝子类 - 按特征分�c�：(x��)拥有黑木耳男屌丝�Q�拥�?span style="color: #000000; font-family: verdana, 'courier new'; line-height: 21px;">撸管王的奛_��?/span>�Q?span style="color: #000000; font-family: verdana, 'courier new'; line-height: 21px;">拥有紫木耳男屌丝�Q?span style="color: #000000; font-family: verdana, 'courier new'; line-height: 21px;">拥有撸神的女屌丝
行�ؓ(f��)实现 - Implementor�Q�屌丝特征设�|�的行�ؓ(f��)�c�d��子类
setFeatures�Q�屌丝特征的讄��接口
setFeatures黑木�?);
setFeatures紫木�?);
代码�Q?/p>
package ITfarmer.designpatterns.study.bridge;
//��试
public class Client
{
    public static void main( String[] argv )
    {
  Features 黑木�? new 男屌丝特�?);

   Features �?/span>木�? new 奛_��丝特�?/span>();

  DiaoSi 拥有黑木耳的男屌�? new ManDiaoSi( 黑木�?nbsp;);
   DiaoSi 拥有紫木耳的男屌�? new ManDiaoSi( 紫木�?nbsp;);
  拥有黑木耳的男屌�?setFeatures();
  拥有紫木耳的男屌�?setFeatures();

  DiaoSi 拥有黑木耳的奛_��? new WomanDiao( 黑木�?);
        Vehicle 拥有紫木耳的奛_��? new WomanDiao( 紫木�?);
  拥有黑木耳的奛_��?setFeatures();
  拥有紫木耳的奛_��?setFeatures();

}
}
package ITfarmer.designpatterns.study.bridge;

*
* @author
* @since 2012/12/05
*/
public abstract class DiaoSi
{
    private Features features;
    Vehicle( Features features)
    {
        this.setFeatures ( features);
    }

    public abstract void setFeatures();
    public void setFeatures( Features features)
    {
        this.features= features;
    }
    public Features getFeatures()
    {
        return  features;
    }
}
package ITfarmer.designpatterns.study.bridge;
//Abstraction子类�Q�这里�ؓ(f��)屌丝抽象�cȝ��子类
public class ManDiaoSi extends DiaoSi
{
    public ManDiaoSi (Features features
)
    {
        super( features
);
    }

    @Override
    public void setFeatures()
{
        System.out.print("男屌丝的特征: ");
  getFeatures.setFeatures();
}
}
package ITfarmer.designpatterns.study.bridge;
//Abstraction子类�Q�这里�ؓ(f��)屌丝抽象�cȝ��子类
public class WomanDiaoSi extends DiaoSi
{
    public WomanDiaoSi ( Features features
)
    {
        super( features
);
    }
    @Override
    public void setFeatures()
{
        System.out.print("奛_��丝的特征: ");
        getFeatures().seFeatures();
    }
}
package ITfarmer.designpatterns.study.bridge;
//屌丝�cȝ��行�ؓ(f��)接口
public interface Features
{
    public void setFeatures();
}
package ITfarmer.designpatterns.study.bridge;
/** ConcreteImplementor */
//行�ؓ(f��)实现子类
public class 男屌丝特�?implements Features
{
    public void setFeatures()
    {
        System.out.println("黑木�?或�?撸管�?);
    }

}
package ITfarmer.designpatterns.study.bridge;
/** ConcreteImplementor */
//行�ؓ(f��)实现子类
public class 奛_��丝特�?nbsp;implements Features
{
    public void setFeatures()
    {
System.out.println("黑木�?或�?撸管�?);
}

}
��结�Q�Bridge模式是一�U�抽象与其实现相分离的模式。它主要应用于：(x��)当事物是一�l�变化量�Q�和对这些事物的操作�Ҏ(gu��)��(实现)也是一�l�变化量的情况，也就是说它们都是多变的�?/span>

��其自然EVO 2012-12-05 16:21 发表评论

久久91亚洲人成电影网站,亚洲欧洲日本天天堂在线观看,国产亚洲精品仙踪林在线播放

操作�pȝ��中内存管理的��面�|�换���法

��目实战�W�记之六�Q�团队徏讄���三种境界

跟屌丝大哥学�?f��n)设计模�?-工厂�Ҏ(gu��)��模式

跟屌丝大哥学�?f��n)设计模�?--生成器模�?Builder)解析例子

跟屌丝大哥学�?f��n)设计模�?--代理模式

实现�c�people

代理�c�talkProxy

应用端myProxyTest

Java 观察者模式的���析

跟屌丝大哥学设计模式-单例模式

跟屌丝学设计模式之责任链模式

java设计模式-桥接模式�Q�屌丝男学设计模式）

操作�pȝ��中内存管理的��面�|�换��法

��目实战�W�记之六�Q�团队徏讄��三种境界

Java　观察者模式的��析