PHP会倒掉吗？

最近有不少文章讨论PHP如何如何不好，如何如何不适应企业应用，如何如何会倒掉的问题。我也发表一下我的看法。

 

我认为PHP的最成功之处在于以下几点：

 

1. 相对简单的语法：PHP的语法构成囊括了C、JAVA、PERL等，这使得熟悉这些语法的人可以很轻易地入门PHP语言，而其他语言则不同，除非用户在一门语言中有了一定的经验，再去学另一门语言能稍微轻松些，但是对于毫无经验的初学者，那是一个痛苦的过程。

 

2. 丰富的类库支持：PHP内置了非常多的函数，而且都使用统一的命名环境，这样PHP开发人员只需要打开PHP参考文档就可以查询到，不必像其他语言那样（如Java），不断地加入第三方类库及学习其使用方法。

 

3. 低廉的部署成本：因为PHP本身就是开源的，因此它使用的环境大多是开源或免费的，况且市面上集成产品很多，如XAMPP，一解压运行个自动安装程序，就可以使用了。再看其他的语言，Java产品中免费的有tomcat，它还是需要进行一些手工配置，且性能非常一般；而ASP.NET的它本身就是收费的，这里就不说了。

 

再者就是，PHP是专门针对网站的，这使得它把全部精力投入到如何优化网站上面，不管是语法结构还是解释引擎。而其他语言如Java或.net，他们是一套通用的语言，网站应用只是其一部分，网站快速开发和应用能力确实没有PHP强。

 

上面几点总结出一句话就是：不用高价的开发人员，不用配置很高的硬件服务器，就可以非常快速地构建网站应用。而这个速度，是其他语言所不能匹敌的。最简单的测试不过是拿一个同样功能的网站，让一帮初级程序员分别用PHP、JAVA、ASP.NET进行开发，看看开发和部署速度的差距就知道了。

 

你会发现，这应该就是PHP的魅力所在。

 

至于OOP，我觉得对于网站的应用来说，只要能以最快的速度满足客户要求就行了，任何产品如果无法满足客户的需求，那使用再好的技术也是扯淡，更何况如果不是大中型项目，OOP是会拖累开发进度的，而目前大部分网站应用来说，基本都是小型项目。

 

而企业应用，我觉得PHP完全可以胜任，因为PHP它内置了支持调用Java和.NET组件，如果自身不行，那就用别人的嘛，只要快速开发的本质不变就行。

 

至少，从我接触PHP的这段时间来看，个人认为它不会垮掉，因为网站应用还没有能像它一样简洁快速的语言出现。（不要说ruby了，它的学习门槛不低啊，而且运行环境配置起来也比较复杂，大部分常用类库也都是外置的）

评论

257 楼 murainwood 2009-12-11  

yipsilon 写道

请楼上的查查 Java HotSpot Server VM 吧，我只是用了比较通俗的话来说这事儿而已。

就像我们开发了两个dll，一个叫client.dll，是客户端，另一个叫server.dll，是通讯服务器，我们封装了一个exe，通过-client参数打开客户端，通过-server参数运行服务器，难道使用后者就不是服务器软件了？这根hotspot的原理是一样的啊。

确实，我觉得这个话题没什么可讨论的。

这个属于基本常识

256 楼 icewubin 2009-12-11  

<div class="quote_title">yipsilon 写道</div>
<div class="quote_div">
<p> </p>
<div class="quote_title">icewubin 写道</div>
<div class="quote_div">server版jvm的特性（4个主要特性），在你列举的第四页上说的很清楚了，你这个“貌似”又是从哪里的出来的结论？<br><br>这两段段说了半天的call stack，说明只和调用的时候才有关，而且更多的是在说安全方面的特性，没有出现你说的只根据单向引用就会把class加载入call stack的内容。</div>
 哎，不知道说你什么好了，仔细看原文吧。让我解释给你听可以，拿咨询费来。呵呵。</div>
<p><br>你解释的又未必一定正确，为什么要给你咨询费？</p>

255 楼 icewubin 2009-12-11  

<div class="quote_title">yipsilon 写道</div>
<div class="quote_div">
<p> </p>
<div class="quote_title">icewubin 写道</div>
<div class="quote_div">你没有理解我的意思，问题就处在你说的“太多”，你可以从微观上来讲，单向引用很多，但是不能推论出宏观上来讲，一个jar包中调用一个类，会牵涉到大部分的类，这一定是错误的，循环引用和双向引用在OO设计上本来就是不多见的，你自己可以看看GOF 23中设计模式中有几个是涉及到循环引用和双向引用的。<br><br>我再举个例子吧，如果你还是不明白，这个话题也可以打住了：<br>假设一个最简单的多态程序，7个类A、B、C、D、E、F、G都继承或实现了接口X，当调用A的时候，只会牵涉到A和X两个类，占整个类的数量的1/4，这还仅仅是一个package中的情况。<br><br>再做个比喻，撇开小部分的双向引用和循环引用，大部分的类图，更像一颗树形结构，从最下面分支开始调用，单向引用，逐渐向上，充其量不过加载了一个很小分支的类的数量，和整棵对象数比起来，根本就是很小的一部分，而不是你说的“不难想象”和“大多数情况”。<br><br>当然我拿不出直接的数字来说明实际的某个项目的jar包中，引用一个类到底会单向引用引出多少类，我也不想在这上和你耗费时间，有兴趣你可以自己写个小工具，或者用某些对象分析工具，把某个包中的对象图分析一下，看看对象树长什么样子。</div>
<p>微观？晕，你真要讲大理论啊。那宏观又是什么呢？服了，哈哈。</p>
<p> </p>
<p>你的这个例子很搞笑，如果X再去调用别的类或接口呢？而别的类或接口再去调用另一些类或接口呢？你这例子才是你所谓的“微观”吧。晕。</p>
<p> </p>
<p>你随便打开个jar包看看吧，类与类之间关联很多的。大多都是单向引用，但不是单层引用（你举的那个例子就是）。</p>
</div>
<p><br>我说的微观、宏观，就是指当一个jar包中的类的数量超过1000以后，就很难确定调用一个类，在对象图中单向引用牵涉到的类占整个类数量的比例。</p>
<p> </p>
<p>类与类之间关联事很多，但是我已经说了，假设一个jar包中100，000个类，你调用某个类的某个方法，引发的单向引用一般都不会超过100个（JDK的类不算），数字肯定不准，但是我认为一般不会超过百分之一甚至千分之一，原理我已经说的够清楚了。</p>
<p> </p>
<p>再举最后一个例子，一个常见的功能网站，分为10个大模块，假设三层结构，MVC设计，基础类算20个左右吧，一个模块估算是10个dao吧，总共100个dao，一个模块也估算是10个service吧，总共100个service，action或web类估算是一个模块5个吧，总共50个类，全部加起来大概270个类，如果一个模块的action触发请求，大概牵涉到一个action，3-5个service，4-6个dao，20个基础类都算上吧，也就30个类而已。</p>
<p> </p>
<p>我举了个最简单的多个类的一个对象图的树形分支的例子，被你解读成单层，唉，不说什么了，也不想再解释了，就此打住吧。</p>

254 楼 yipsilon 2009-12-11  

<p>
</p>
<div class="quote_title">icewubin 写道</div>
<div class="quote_div">你没有理解我的意思，问题就处在你说的“太多”，你可以从微观上来讲，单向引用很多，但是不能推论出宏观上来讲，一个jar包中调用一个类，会牵涉到大部分的类，这一定是错误的，循环引用和双向引用在OO设计上本来就是不多见的，你自己可以看看GOF 23中设计模式中有几个是涉及到循环引用和双向引用的。<br><br>我再举个例子吧，如果你还是不明白，这个话题也可以打住了：<br>假设一个最简单的多态程序，7个类A、B、C、D、E、F、G都继承或实现了接口X，当调用A的时候，只会牵涉到A和X两个类，占整个类的数量的1/4，这还仅仅是一个package中的情况。<br><br>再做个比喻，撇开小部分的双向引用和循环引用，大部分的类图，更像一颗树形结构，从最下面分支开始调用，单向引用，逐渐向上，充其量不过加载了一个很小分支的类的数量，和整棵对象数比起来，根本就是很小的一部分，而不是你说的“不难想象”和“大多数情况”。<br><br>当然我拿不出直接的数字来说明实际的某个项目的jar包中，引用一个类到底会单向引用引出多少类，我也不想在这上和你耗费时间，有兴趣你可以自己写个小工具，或者用某些对象分析工具，把某个包中的对象图分析一下，看看对象树长什么样子。</div>

<p>微观？晕，你真要讲大理论啊。那宏观又是什么呢？服了，哈哈。</p>
<p> </p>
<p>你的这个例子很搞笑，如果X再去调用别的类或接口呢？而别的类或接口再去调用另一些类或接口呢？你这例子才是你所谓的“微观”吧。晕。</p>
<p> </p>
<p>你随便打开个jar包看看吧，类与类之间关联很多的。大多都是单向引用，但不是单层引用（你举的那个例子就是）。</p>

253 楼 yipsilon 2009-12-11  

<p>
</p>
<div class="quote_title">icewubin 写道</div>
<div class="quote_div">server版jvm的特性（4个主要特性），在你列举的第四页上说的很清楚了，你这个“貌似”又是从哪里的出来的结论？<br><br>这两段段说了半天的call stack，说明只和调用的时候才有关，而且更多的是在说安全方面的特性，没有出现你说的只根据单向引用就会把class加载入call stack的内容。</div>
 哎，不知道说你什么好了，仔细看原文吧。让我解释给你听可以，拿咨询费来。呵呵。

252 楼 yipsilon 2009-12-11  

请楼上的查查 Java HotSpot Server VM 吧，我只是用了比较通俗的话来说这事儿而已。

就像我们开发了两个dll，一个叫client.dll，是客户端，另一个叫server.dll，是通讯服务器，我们封装了一个exe，通过-client参数打开客户端，通过-server参数运行服务器，难道使用后者就不是服务器软件了？这根hotspot的原理是一样的啊。

确实，我觉得这个话题没什么可讨论的。

251 楼 murainwood 2009-12-11  

1). 你根本就不知道server版的jvm，总拿client版的jvm特性说事儿，居然还搞出了“Server版的J2EE服务器”这样搞笑的词语，要知道现在几乎所有公开使用J2EE技术的网站，其App server用的jvm都是server版的。

--------------“Server版的JVM”，笑死了。开个-server 参数就被称为“Server版JVM”，第一次听说

250 楼 murainwood 2009-12-11  

这个世界上总有些人，连高中物理都没上过，就宣称推翻了广义相对论。

249 楼 icewubin 2009-12-11  

<div class="quote_title">yipsilon 写道</div>
<div class="quote_div">
<p><span style="font-size: medium; font-family: Simsun;">
<div>
<p style="margin: 0px;"> </p>
<div>
<div class="quote_title" style="font-weight: bold; margin-top: 5px; margin-right: 0px; margin-bottom: 0px; margin-left: 15px; padding: 5px;">icewubin 写道</div>
<div class="quote_div">拜托，如果我不仔细看，怎么知道Server VM的特性的？<br><br>我真是全篇看了下，最后为了保险起见再搜了把loader，真没找到啊。<br><br>我也知道很累，实在找不到才请教你啊。第四个我刚才就看过，所以还记得特别清楚，在你给我链接之前，我就已经看过了。</div>
<p style="margin: 0px;"> </p>
<p style="margin: 0px;"> 貌似，讨论到现在，没看到你对server版jvm的特性有多少了解。</p>
<p style="margin: 0px;"> </p>
<p style="margin: 0px;">不过最后一句话挺好玩儿，真的仔细看过了？难道没有看到这个？</p>
<p style="margin: 0px;"> </p>
<div class="quote_div"><span style="font-size: medium; font-family: Simsun;">Checking the protection domains on the call stack presents no problem for interpreted code. For interpreted code, the stack is a true source-level call stack that exactly represents the structure of the bytecodes being executed. When compiling and inlining code, however, the information in the stack can become scrambled. Once compiled code from one method has been inlined into another method's code in a second class, the first class no longer appears on the call stack, and its protection domain cannot be checked by the platform's security mechanism. This presents a real obstacle for JIT and static compilers, and forces them to be very conservative in their inlining so they don't compromise security.</span></div>
<div class="quote_div"><span style="font-size: medium; font-family: Simsun;">The Java HotSpot Server VM surmounts this problem by using, in effect, <em>two</em> call stacks. One stack reflects the fully optimized state of the dynamically compiled code, and HotSpot uses this stack for running the program. HotSpot also constructs on demand a second, ``virtual'' stack that retains the source-level call structure of the original bytecode. By referring to the virtual stack as necessary, the Java HotSpot Server VM can achieve the security of an interpreter while retaining the full performance benefits of its optimizing compiler.</span></div>
<p style="margin: 0px;">还有下面的Method Inlining的话，如果英文能看懂的话，你分析一下就知道了。</p>
</div>
<p> </p>
</div>
</span></p>
</div>
<p><br>server版jvm的特性（4个主要特性），在你列举的第四页上说的很清楚了，你这个“貌似”又是从哪里的出来的结论？</p>
<p> </p>
<p>这两段段说了半天的call stack，说明只和调用的时候才有关，而且更多的是在说安全方面的特性，没有出现你说的只根据单向引用就会把class加载入call stack的内容。</p>

248 楼 icewubin 2009-12-11  

<div class="quote_title">yipsilon 写道</div>
<div class="quote_div">
<div class="quote_title">icewubin 写道</div>
<div class="quote_div">
<p>大多数情况下就是这样的。</p>
<p> </p>
<p>大多数情况下，都是单向引用的对象图，循环引用或双向引用的出现概率一般都是不高的，即使有，也只是在很小一部分类之间有循环引用、或双向引用。</p>
</div>
<p>我之前举的“A引用B、B引用C”是单向引用吧？这样的例子<span style="color: #ff0000;"><strong>太多</strong></span>了啊，难道你写的工具类一点儿也不调用其他的API？就拿你之前跟别人讨论的lucene来说，<span style="color: #000000;">你如果调用了他里面的一个类，它势必要装载包中其他相关的类进入到内存中。</span>这对于你的工具类来说，都是单向引用。</p>
</div>
<p><br>你没有理解我的意思，问题就处在你说的“太多”，你可以从微观上来讲，单向引用很多，但是不能推论出宏观上来讲，一个jar包中调用一个类，会牵涉到大部分的类，这一定是错误的，循环引用和双向引用在OO设计上本来就是不多见的，你自己可以看看GOF 23中设计模式中有几个是涉及到循环引用和双向引用的。</p>
<p> </p>
<p>我再举个例子吧，如果你还是不明白，这个话题也可以打住了：</p>
<p>假设一个最简单的多态程序，7个类A、B、C、D、E、F、G都继承或实现了接口X，当调用A的时候，只会牵涉到A和X两个类，占整个类的数量的1/4，这还仅仅是一个package中的情况。</p>
<p> </p>
<p>再做个比喻，撇开小部分的双向引用和循环引用，大部分的类图，更像一颗树形结构，从最下面分支开始调用，单向引用，逐渐向上，充其量不过加载了一个很小分支的类的数量，和整棵对象数比起来，根本就是很小的一部分，而不是你说的“不难想象”和“大多数情况”。</p>
<p> </p>
<p>当然我拿不出直接的数字来说明实际的某个项目的jar包中，引用一个类到底会单向引用引出多少类，我也不想在这上和你耗费时间，有兴趣你可以自己写个小工具，或者用某些对象分析工具，把某个包中的对象图分析一下，看看对象树长什么样子。</p>
<p> </p>
<p> </p>

247 楼 yipsilon 2009-12-11  

<p><span style="font-family: Simsun; font-size: medium;">
<div style="">
<p style="margin: 0px;"> </p>
<div style="">
<div class="quote_title" style="font-weight: bold; margin-top: 5px; margin-right: 0px; margin-bottom: 0px; margin-left: 15px; padding: 5px;">icewubin 写道</div>
<div class="quote_div" style="">拜托，如果我不仔细看，怎么知道Server VM的特性的？<br><br>我真是全篇看了下，最后为了保险起见再搜了把loader，真没找到啊。<br><br>我也知道很累，实在找不到才请教你啊。第四个我刚才就看过，所以还记得特别清楚，在你给我链接之前，我就已经看过了。</div>
<p style="margin: 0px;"> </p>
<p style="margin: 0px;"> 貌似，讨论到现在，没看到你对server版jvm的特性有多少了解。</p>
<p style="margin: 0px;"> </p>
<p style="margin: 0px;">不过最后一句话挺好玩儿，真的仔细看过了？难道没有看到这个？</p>
<p style="margin: 0px;"> </p>
<div class="quote_div" style=""><span style="font-family: Simsun; font-size: medium;">Checking the protection domains on the call stack presents no problem for interpreted code. For interpreted code, the stack is a true source-level call stack that exactly represents the structure of the bytecodes being executed. When compiling and inlining code, however, the information in the stack can become scrambled. Once compiled code from one method has been inlined into another method's code in a second class, the first class no longer appears on the call stack, and its protection domain cannot be checked by the platform's security mechanism. This presents a real obstacle for JIT and static compilers, and forces them to be very conservative in their inlining so they don't compromise security.</span></div>
<div class="quote_div" style=""><span style="font-family: Simsun; font-size: medium;">The Java HotSpot Server VM surmounts this problem by using, in effect, <em>two</em> call stacks. One stack reflects the fully optimized state of the dynamically compiled code, and HotSpot uses this stack for running the program. HotSpot also constructs on demand a second, ``virtual'' stack that retains the source-level call structure of the original bytecode. By referring to the virtual stack as necessary, the Java HotSpot Server VM can achieve the security of an interpreter while retaining the full performance benefits of its optimizing compiler.</span></div>
<p style="margin: 0px;">还有下面的Method Inlining的话，如果英文能看懂的话，你分析一下就知道了。</p>
</div>
<p> </p>
</div>
</span></p>

246 楼 yipsilon 2009-12-11  

<div class="quote_title">icewubin 写道</div>
<div class="quote_div">
<p>大多数情况下就是这样的。</p>
<p> </p>
<p>大多数情况下，都是单向引用的对象图，循环引用或双向引用的出现概率一般都是不高的，即使有，也只是在很小一部分类之间有循环引用、或双向引用。</p>
</div>
<p>我之前举的“A引用B、B引用C”是单向引用吧？这样的例子太多了啊，难道你写的工具类一点儿也不调用其他的API？就拿你之前跟别人讨论的lucene来说，你如果调用了他里面的一个类，它势必要装载包中其他相关的类进入到内存中。这对于你的工具类来说，都是单向引用。</p>

245 楼 icewubin 2009-12-11  

<div class="quote_title">yipsilon 写道</div>
<div class="quote_div">
<div class="quote_title">icewubin 写道</div>
<div class="quote_div">
<p>第一个相关的说了如何Using，第二个相关的说了Settings，第三个相关的说了各平台的Default VM，第四个说了Server VM的特性：Security、Robustness、Dynamic Compilation、Summary，连个class loader的影子都没有。</p>
</div>
<p>找文章很累的，不要轻易地浪费掉别人的工作成果。你本来就有断章取义的习惯，麻烦你一句一句仔细看完吧，不要用搜索功能搜那些词组啦。<img src="/images/smiles/icon_confused.gif" alt=""></p>
</div>
<p><br>拜托，如果我不仔细看，怎么知道Server VM的特性的？</p>
<p> </p>
<p>我真是全篇看了下，最后为了保险起见再搜了把loader，真没找到啊。</p>
<p> </p>
<p>我也知道很累，实在找不到才请教你啊。第四个我刚才就看过，所以还记得特别清楚，在你给我链接之前，我就已经看过了。</p>

244 楼 icewubin 2009-12-11  

<div class="quote_title">yipsilon 写道</div>
<div class="quote_div">
<div class="quote_title">icewubin 写道</div>
<div class="quote_div">你说的“不难想象”和“大都数情况下”都是没有依据的：<br><br>例如A引用了Z，B引用了Z，classloader加载了A，也只会加载Z，而不会加载B。<br><br>所以我反而认为大多数情况下，一个jar包里的类是不相关联的，当然我这里说的不相关联是指classloader不会从Z加载到B的，因为B引用Z是单向的。<br>
</div>
<p>这个你说对了，但是如果A引用B、B引用C了，那么在server版中ABC都会被预先加载，而client版中只有在调用A中使用B的方法时B才会被真正加载。</p>
<p> </p>
<p>J2EE中，同技术中API之间的关联性很大，其实现中关联度也可想而知了。在j2ee container启动时，势必要加载大部分的类数据，启动缓慢是正常的，但是由于都是预先加载且优化好了，在执行时速度比client版快多了。</p>
<p> </p>
<p>从你的观点来考虑，这也是有可能的，比如你做了个工具类库包，里面的类不依赖于任何其他技术的API，这样可以做到，<span style="color: #ff0000;"><strong>但是大多数情况下可能么</strong></span>？呵呵。</p>
</div>
<p><br>大多数情况下就是这样的。</p>
<p> </p>
<p>大多数情况下，都是单向引用的对象图，循环引用或双向引用的出现概率一般都是不高的，即使有，也只是在很小一部分类之间有循环引用、或双向引用。</p>

243 楼 yipsilon 2009-12-11  

<div class="quote_title">icewubin 写道</div>
<div class="quote_div">
<p>第一个相关的说了如何Using，第二个相关的说了Settings，第三个相关的说了各平台的Default VM，第四个说了Server VM的特性：Security、Robustness、Dynamic Compilation、Summary，连个class loader的影子都没有。</p>
</div>
<p>找文章很累的，不要轻易地浪费掉别人的工作成果。你本来就有断章取义的习惯，麻烦你一句一句仔细看完吧，不要用搜索功能搜那些词组啦。<img src="/images/smiles/icon_confused.gif" alt=""></p>

242 楼 yipsilon 2009-12-11  

<div class="quote_title">icewubin 写道</div>
<div class="quote_div">你说的“不难想象”和“大都数情况下”都是没有依据的：<br><br>例如A引用了Z，B引用了Z，classloader加载了A，也只会加载Z，而不会加载B。<br><br>所以我反而认为大多数情况下，一个jar包里的类是不相关联的，当然我这里说的不相关联是指classloader不会从Z加载到B的，因为B引用Z是单向的。<br>
</div>
<p>这个你说对了，但是如果A引用B、B引用C了，那么在server版中ABC都会被预先加载，而client版中只有在调用A中使用B的方法时B才会被真正加载。</p>
<p> </p>
<p>J2EE中，同技术中API之间的关联性很大，其实现中关联度也可想而知了。在j2ee container启动时，势必要加载大部分的类数据，启动缓慢是正常的，但是由于都是预先加载且优化好了，在执行时速度比client版快多了。</p>
<p> </p>
<p>从你的观点来考虑，这也是有可能的，比如你做了个工具类库包，里面的类不依赖于任何其他技术的API，这样可以做到，但是大多数情况下可能么？呵呵。</p>

241 楼 icewubin 2009-12-11  

<div class="quote_title">yipsilon 写道</div>
<div class="quote_div">
<div class="quote_title">icewubin 写道</div>
<div class="quote_div">
<div class="quote_title">yipsilon 写道</div>
<div class="quote_div">
<p> </p>
<p> </p>
<p>哎，算了，还是给你找个吧 <a href="http://java.sun.com/javase/technologies/hotspot/index.jsp">http://java.sun.com/javase/technologies/hotspot/index.jsp</a></p>
</div>
<p><br>拜托，我刚才还看过，哪里有说-server会自动加载所有关联的class，没有的吧，不要给个目录啊，给出具体的URL啊。</p>
</div>
<p><a href="http://java.sun.com/products/hotspot/2.0/README.html">http://java.sun.com/products/hotspot/2.0/README.html</a></p>
<p> </p>
<p><a href="http://download.oracle.com/docs/cd/E13155_01/wlp/docs103/quickstart/memory.html">http://download.oracle.com/docs/cd/E13155_01/wlp/docs103/quickstart/memory.html</a></p>
<p> </p>
<p><a href="http://java.sun.com/j2se/1.5.0/docs/guide/vm/server-class.html">http://java.sun.com/j2se/1.5.0/docs/guide/vm/server-class.html</a></p>
<p> </p>
<p><a href="http://java.sun.com/products/hotspot/docs/general/hs2.html">http://java.sun.com/products/hotspot/docs/general/hs2.html</a></p>
<p> </p>
<p>先找这四个，你多多理解吧。</p>
</div>
<p><br>第一个相关的说了如何Using，第二个相关的说了Settings，第三个相关的说了各平台的Default VM，第四个说了Server VM的特性：Security、Robustness、Dynamic Compilation、Summary，连个class loader的影子都没有。</p>

240 楼 yipsilon 2009-12-11  

<p>
</p>
<div class="quote_title">icewubin 写道</div>
<div class="quote_div">你列了个JavaEE6？唉，原来之前的那些JavaEE或者J2EE都不算的啊。（到此发现原来你说的J2EE Container的前提条件是要实现JavaEE6，不讨论了，真累啊。）</div>
 resin只支持ejb 3.0啊，列表中技术跟J2EE 5.0的差不多，多数只是版本号不同而已，但我要是找更老一点儿的版本，你又好找理由开脱了，哈哈。

239 楼 icewubin 2009-12-11  

yipsilon 写道

1. 我说的错误是指：“一个jar包里的类都是相关联的，不难想象”。

1. 这个你真应该承认错误，我之前说的是什么？“大都数情况下”

你说的“不难想象”和“大都数情况下”都是没有依据的：

例如A引用了Z，B引用了Z，classloader加载了A，也只会加载Z，而不会加载B。

所以我反而认为大多数情况下，一个jar包里的类是大多数是“不相关联”的，当然我这里说的“不相关联”是指classloader不会从Z加载到B的，因为B引用Z是单向的。

238 楼 yipsilon 2009-12-11  

<div class="quote_title">icewubin 写道</div>
<div class="quote_div">
<div class="quote_title">yipsilon 写道</div>
<div class="quote_div">
<p> </p>
<p> </p>
<p>哎，算了，还是给你找个吧 <a href="http://java.sun.com/javase/technologies/hotspot/index.jsp">http://java.sun.com/javase/technologies/hotspot/index.jsp</a></p>
</div>
<p><br>拜托，我刚才还看过，哪里有说-server会自动加载所有关联的class，没有的吧，不要给个目录啊，给出具体的URL啊。</p>
</div>
<p><a href="http://java.sun.com/products/hotspot/2.0/README.html">http://java.sun.com/products/hotspot/2.0/README.html</a></p>
<p> </p>
<p><a href="http://download.oracle.com/docs/cd/E13155_01/wlp/docs103/quickstart/memory.html">http://download.oracle.com/docs/cd/E13155_01/wlp/docs103/quickstart/memory.html</a></p>
<p> </p>
<p><a href="http://java.sun.com/j2se/1.5.0/docs/guide/vm/server-class.html">http://java.sun.com/j2se/1.5.0/docs/guide/vm/server-class.html</a></p>
<p> </p>
<p><a href="http://java.sun.com/products/hotspot/docs/general/hs2.html">http://java.sun.com/products/hotspot/docs/general/hs2.html</a></p>
<p> </p>
<p>先找这四个，你多多理解吧。</p>