一艘没有航行目标的船，任何方向的风都是逆风

1、你为什么是穷人，第一点就是你没有立下成为富人的目标

2、你的人生核心目标是什么？

杰出人士与平庸之辈的根本差别并不是天赋、机遇，而在于有无目标。

3、起跑领先一步，人生领先一大步：成功从选定目标开始

4、贾金斯式的人永远不会成功

为什么大多数人没有成功？真正能完成自己计划的人只有5%，大多数人不是将自己的目标舍弃，就是沦为缺乏行动的空想

5、如果你想在35岁以前成功，你一定在25至30岁之间确立好你的人生目标

6、每日、每月、每年都要问自己：我是否达到了自己定下的目标

二：两个成功基点

站好位置，调正心态，努力冲刺，35岁以前成功

(一)人生定位

1、人怕入错行：你的核心竞争力是什么？

2、成功者找方法，失败者找借口

3、从三百六十行中选择你的最爱

人人都可以创业，但却不是人人都能创业成功

4、寻找自己的黄金宝地

(二)永恒的真理：心态决定命运，35岁以前的心态决定你一生的命运

1、不满现状的人才能成为富翁

2、敢于梦想，勇于梦想，这个世界永远属于追梦的人

3、 35岁以前不要怕，35岁以后不要悔

4、出身贫民，并非一辈子是贫民，只要你永远保持那颗进取的心。中国成功人士大多来自小地方

5、做一个积极的思维者

6、不要败给悲观的自己

有的人比你富有一千倍，他们也会比你聪明一千倍么？不会，他们只是年轻时心气比你高一千倍。

人生的好多次失败，最后并不是败给别人，而是败给了悲观的自己。

7、成功者不过是爬起来比倒下去多一次

8、宁可去碰壁，也不要在家里面壁

克服你的失败、消极的心态

(1)找个地方喝点酒

(2)找个迪厅跳跳舞

(3)找帮朋友侃侃山

(4)积极行动起来

三：三大技巧

1、管理时间：你的时间在哪里，你的成就就在哪里。

把一小时看成60分钟的人，比看作一小时的人多60倍

2、你不理财，财不理你

3、自我管理，游刃有余

(1)创业不怕本小，脑子一定要好

(2)可以开家特色店

(3)做别人不愿做的生意

四：四项安身立命的理念

35岁以前一定要形成个人风格

1、做人优于做事

做事失败可以重来，做人失败却不能重来

(1)做人要讲义气

(2)永不气馁

2、豁达的男人有财运，豁达的女人有帮夫运

35岁以前搞定婚姻生活

3、忠诚的原则：35岁以前你还没有建立起忠诚美誉，这一缺点将要困扰你的一生

4、把小事做细，但不要耍小聪明

中国人想做大事的人太多，而愿把小事做完美的人太少

五：五分运气

比尔·盖茨说：人生是不公平的，习惯去接受它吧

1、人生的确有很多运气的成人：谋事在人，成事在天：中国的古训说明各占一半

2、机会时常意外地降临，但属于那些不应决不放弃的人

3、抓住人生的每一次机会

机会就像一只小鸟，如果你不抓住，它就会飞得无影无踪

4、者早一步，愚者晚一步

六：六项要求

1、智慧

(1)别人可你以拿走你的一切，但拿不走你的智慧

(2)巧妙运用自己的智慧

(3)智者与愚者的区别

2、勇气

(1)勇气的力量有时会让你成为“超人”

(2)敢于放弃，敢于“舍得”

3、培养自己的“领导才能、领袖气质”

(1)激情感染别人

(2)“三·七法则”实现领袖气质

(3)拍板决断能力

(4)人格魅力

4、创造性：不要做循规蹈矩的人

25-35岁是人生最有创造性的阶段，很多成功人士也都产生在这一阶段

5、明智

(1)知道自己的长处、短处，定向聚焦

(2)尽量在自己的熟悉的领域努力

6、持之以恒的行动力：在你选定行业坚持十年，你一定会成为大赢家

七：七分学习

1、知识改变命运

2、35岁以前学会你行业中必要的一切知识

a)每天淘汰你自己

b)在商言商

3、太相信的书人，只能成为打工仔

4、思考、实践、再思考、再实践

八：八分交际

朋友多了路好走

1、智商很重要，情商更重要：35岁以前建立起人际关系网

2、人脉即财脉：如何搞好人际关系

3、交友有原则

4、善于沟通：35岁以前要锻炼出自己的演讲才能

九：九分习惯

习惯的力量是惊人的，35岁以前养成的习惯决定着你的成功的大小

1、积极思维的好习惯

2、养成高效工作的好习惯

(1)办公室

(2)生活可以不拘小节，但要把工作做细

(3)学习聆听，不打断别人说话

3、养成锻炼身体的好习惯

4、广泛爱好的好习惯

5、快速行动的好习惯

十：十分自信

1、自信是成功的精神支柱

2、自信方能赢得别人的信任

3、把自信建立在创造价值的基础上

4、如何建立自信

(1)为自己确立目标

(2)发挥自己的长处

(3)做事要有计划

(4)做事不拖拉

(5)轻易不要放弃

(6)学会自我激励

(7)不要让自己成为别人 十一： 11个需要避开的成功陷阱

1、只有功劳，没有苦劳

2、不要“怀才不遇“，而要寻找机遇

3、不要想发横财

4、不要为钱而工作，而让钱为你工作

5、盲目跟风，人云亦云，人做我也做

6、小富即安，不思进取，知足常乐

7、承认错误而非掩饰错误

8、脚踏实地而非想入非非

9、野心太大而不是信心十足

10、反复跳槽不可取

11、眼高手低

12、不择手段

十二：十二分努力

没有人能随随便便成功

1、小不是成功，大不是成功，由小变大才是成功

2、中国社会进入微利时代：巧干+敢干+实干=成功

3、努力尝试就有成功的可能

4、做任何事情，尽最大努力

5、把事情当成事业来做

6、我看打工者

7、祝你早日掘到第一桶金来源

Ajax -- Asynchronous JavaScript and XML Ajax 使用的是JavaScript + DOM + CSS + XMLHttpRequest的技术,是目前Web2.0更加流行的技术.

与传统网络应用相比,Ajax具备更加直观和方便的用户交互. 为什么呢? 比如, 我们需要点击链接或按钮来激发事件,而使用Ajax只要移动鼠标或者在一个输入框输入字母已经可以触发事件. 传统的网络应用是基于page-driven的模式, 使用的是'click, wait a refresh the whole page' 模式, 而Ajax是通过data-driven的模式来提供网络页面的, 采用的是部分页面更新的模式, 页面中只更新有新数据的部分,其它的部分依然不变,所以依然可以操作.

Ajax就象它的名字一样, 可以异步地在浏览器和服务器之间进行交流, 当服务器端处理submit过来的数据的同时, 客户依然可以正常地处理浏览器端同一页面的其他功能.

那么Ajax和传统网络应用相比是怎样工作的呢?下面这张图可以让你了解清楚.

传统的网络应用在浏览器和服务器之间的交流是直来直去的, 而Ajax的网络应用在浏览器中有一个Ajax引擎,这个引擎实际上就是一个Javascript的对象XMLHttpRequest, 而XMLHttpRequest负责浏览器和服务器的异步交流.

XMLHttpRequest既然是Javascript的对象, 当然需要一些Javascript的代码来生成, 它目前支持大部分的浏览器,包括了Mozilla, Firefox等等.

服务器端依然可以使用传统的技术如servlet, JSP, JSF,Struts等等,但会有一些小的限制,比如客户端会发更频繁的请求,而响应这些请求的类型包括text/xml, text/plain, text/json, text/javascript.

整个Ajax的操作过程分为七步:

1.A client event occurs

2.An XMLHttpRequest object is created

3.The XMLHttpRequest object is configured

4.The XMLHttpRequest object makes an async. request

5.The ValidateServlet returns an XML document containing the result

6.The XMLHttpRequest object calls the callback() function and processes the result

7.The HTML DOM is updated

我们分别来看看这七个步骤是怎么做的: 1. A client event occurs,

<input type="text"
size="20"
id="userid"
name="id"
onkeyup="validateUserId();">

比如我们手头上有这样一段Javascript的代码:  这是一个ID为userid的文本框,里面包含了一个Javascript的函数,当我们在文本框里打入一个英文字母时,会激发onkeyup的事件,从而激发validateUserId的Javascript的函数.

2.An XMLHttpRequest object is created

var req;
function initRequest() {
if (window.XMLHttpRequest) {
req = new XMLHttpRequest();
} else if (window.ActiveXObject) {
isIE = true;
req = new ActiveXObject("Microsoft.XMLHTTP");
}
}
function validateUserId() {
initRequest();
req.onreadystatechange = processRequest;
if (!target) target = document.getElementById("userid");
var url = "validate?id=" + escape(target.value);
req.open("GET", url, true);
req.send(null);
}

validateUserId的Javascript的函数调用initRequest函数生成XMLHttpRequest对象, 大家注意到在initRequest函数里面有两种生成XMLHttpRequest的方法,这是针对不同的浏览器的做法,对于Mozilla,我们可以直接使用"new XMLHttpRequest()”, 而对于IE,我们需要生成ActiveX对象.

3.The XMLHttpRequest object is configured

rvalidateUserId的Javascript的函数包含一句req.onreadystatechange = processRequest; 这是通过设定XMLHttpRequest对象里面的onreadystatechange特性为回调函数.

4.The XMLHttpRequest object makes an async. request

if (!target) target = document.getElementById("userid");
var url = "validate?id=" + escape(target.value);
req.open("GET", url, true);
req.send(null);

然后XMLHttpRequest调用open方法和服务器交流, open方法有三个参数, HTTP方法是Get还是Post, 服务器端的URL, 方式采取异步还是同步.

5.The ValidateServlet returns an XML document containing the result

public void doGet(HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException {
String targetId = request.getParameter("id");
if ((targetId != null) && !accounts.containsKey(targetId.trim())) {
response.setContentType("text/xml ");
response.setHeader("Cache-Control", "no-cache");
response.getWriter().write("<valid>true</valid>");
} else {
response.setContentType("text/xml ");
response.setHeader("Cache-Control", "no-cache");
response.getWriter().write("<valid>false</valid>");
}
}

然后是服务器端ValidateServlet的响应,首先Content type设为text/xml, Cache-Control设为no-cache, 最后会返回true或者false的xml格式响应.

6.The XMLHttpRequest object calls the callback() function and processes the result

function processRequest() {
if (req.readyState == 4) {
if (req.status == 200) {
var message = ...;

现在控制交回给客户端, 由于我们设定了回调函数为processRequest, 那么当响应从服务器端回到客户端浏览器,就激发了processRequest函数, 我们在processRequest函数中检查XMLHttpRequest对象的readyState状态是否为4和status状态是否为200,如果两者同时成立,就代表服务器端的数据已经成功返回给客户端,那么就可以执行下面的处理.

 7.The HTML DOM is updated.

接收完服务器端传回来的数据后,浏览器开始着手显示接收回的数据.

我们通过页面里面的<div>元素来唯一的表示一个对象给DOM的API使用. 比如确定html页面某一处的需要显示的信息文本对象,我们可以使用userIdMessage唯一的标签来做引用给DOM的API使用. 如下面这段代码:

23.<body>
24. <div id="userIdMessage"></div>
25.</body>

一但你有了唯一确定的引用,你就可以使用DOM的API对其进行随心所欲的操作,如属性的修改等等,比如下面这段代码:

1. <script type="text/javascript">
2. function setMessageUsingDOM(message) {
3. var userMessageElement = document.getElementById("userIdMessage");
4. var messageText;
5. if (message == "false") {
6. userMessageElement.style.color = "red";
7. messageText = "Invalid User Id";
8. } else {
9. userMessageElement.style.color = "green";
10. messageText = "Valid User Id";
11. }
12. var messageBody = document.createTextNode(messageText);
13. // if the messageBody element has been created simple replace it otherwise
14. // append the new element
15. if (userMessageElement.childNodes[0]) {
16. userMessageElement.replaceChild(messageBody,
17. userMessageElement.childNodes[0]);
18. } else {
19. userMessageElement.appendChild(messageBody);
20. }
21.}
22.</script>
23.<body>
24. <div id="userIdMessage"></div>
25.</body>

在这里javascript通过了getElementById方法得到了userIdMessage对象,然后对服务器端返回的数据进行对比,如果值是true,在userIdMessage里添加文本"Valid User Id", 如果值是false,则在userIdMessage里添加文本"Invalid User Id".

大概就是这样的一个状况,那么在Ajax里面的XMLHttpRequest还有很多方法和属性, 包括:

方法:

• open(“HTTP method”, “URL”, syn/asyn)
> Assigns HTTP method, destination URL, mode
• send(content)
> Sends request including string or DOM object data
• abort()
> Terminates current request
• getAllResponseHeaders()
> Returns headers (labels + values) as a string
• getResponseHeader(“header”)
> Returns value of a given header
• setRequestHeader(“label”,”value”)
> Sets Request Headers before sending

属性:

• onreadystatechange
> Set with an JavaScript event handler that fires at each
change
• readyState – current status of request
> 0 = uninitialized
> 1 = loading
> 2 = loaded
> 3 = interactive (some data has been returned)
> 4 = complete
• status
> HTTP Status returned from server: 200 = OK

• responseText
> String version of data returned from the server
• responseXML
> XML document of data returned from the server
• statusText
> Status text returned from server

Posted at 05:22PM Jul 10, 2007 by Benny Luo

LISTENER =
  (DESCRIPTION_LIST =
    (DESCRIPTION =
      (ADDRESS = (PROTOCOL = IPC)(KEY = EXTPROC1))
      (ADDRESS = (PROTOCOL = TCP)(HOST = localhost)(PORT = 1521))
    )
  )
中红色标识的localhost改为机器名，如：mycoputer

---------------------------------------------------------------------------­-----
作者：luyongshou 2005-02-02 15:04:45 来自：Linux先生  在此介绍一下我在RedHat Linux 7.2下装Apache与Tomcat4整合的过程，重点讲述mod_webapp.so的制作方法，
　　以及在虚拟主机环境下的配置、管理和应用，经测试已经成功。希望对各位有所帮助，如有错误也请指正。

一、正确安装Tomcat4
　　必要软件的安装，如下：
　　1、Java SDK
　　版本1.3.1或1.4，建议安装在/usr/java下，并做一个jdk的软链接。
　　如果在装版本1.3.1的SDK出现问题，请阅读文档：http://java.sun.com/j2se/1.3/install-linux-sdk.html
　　2、Tomcat4
　　建议安装最新release版本的二进制文件安装包。当前最新的tomcat版本是4.1.12。
　　下载地址：
　　http://jakarta.apache.org/builds/ja...t-4.1.12.tar.gz
　 下载后接压到一个目录 "tar xvzf jakarta-tomcat-4.1.12.tar.gz"
本例将tomcat安装在/opt目录下，并做了个tomcat的软链接。
　　设置如下环境变量并启用：
　　PATH=$PATH:/usr/java/jdk/bin:/usr/java/jdk/jre/bin
　 JAVA_HOME=/usr/java/jdk
　　export JAVA_HOME
　　CLASSPATH="./:/usr/java/jdk/lib:/usr/java/jdk/jre/lib"
　　export CLASSPATH
　　CATALINA_HOME=/opt/tomcat
　　export CATALINA_HOME

　　建议单建一个用户tomcat，将其设成/opt/tomcat以下所有目录文件的属主，并由它启动tomcat：
　　# useradd tomcat
　　# chown -R tomcat:tomcat /opt/tomcat
　　# su - tomcat -c "/opt/tomcat/bin/startup.sh"

　　访问http://localhost:8080/ 应能看到tomcat安装成功的页面。

===================================================================
如果想和apache集成需要修改tomcat/conf/server.xml这个文件的

<!-- Define an Apache-Connector Service -->

<Service name="Tomcat-Apache">
<!--
<Connector className="org.apache.catalina.connector.warp.WarpConnector"
port="8008" minProcessors="5" maxProcessors="75"
enableLookups="true" appBase="webapps"
acceptCount="10" debug="0"/>

<Engine className="org.apache.catalina.connector.warp.WarpEngine"
name="Apache" debug="0">

<Logger className="org.apache.catalina.logger.FileLogger"
prefix="apache_log." suffix=".txt"
timestamp="true"/>

<Realm className="org.apache.catalina.realm.MemoryRealm" />

</Engine>

</Service>
-->
</Server>

中的"<!--"和"-->"删掉,其实就是解除注释，因为这个网站是专门用来和apache的集成的。

二、Apache与Tomcat4的整合

　　1、首先安装Apache，
　　请注意Apache必须安装DSO模式，即在执行./configure时须加上 --enable-module=so

　　默认安装到/usr/local/apache目录下。本例安装的apache的版本是2.0.43系列的。

　　2、制作mod_webapp.so
　　需要以下软件包：
　　jakarta-tomcat-connectors-4.x.xx-src.tar.gz
　　下载地址在tomcat对应版本的src目录下。例如，我安装的tomcat版本是4.1.12，则现在所需要的软件包的位置是：
　　http://jakarta.apache.org/builds/ja...1.12-src.tar.gz
　　apr-0.9.1.tar.gz
　　下载地址：http://www.apache.org/dist/apr/apr-0.9.1.tar.gz
　　autoconf-2.52-ximian.1.i386.rpm
　　下载地址：http://rpmfind.net/linux/RPM/helix/...ian.1.i386.html
　　先用rpm安装autoconf-2.52，因为下面的安装将要用到；
　　然后解开jakarta-tomcat-connectors-4.1.12-src.tar.gz，生成jakarta-tomcat-connectors­-4.1.12-src目录，
　　进入jakarta-tomcat-connectors-4.1.12-src/webapp的目录里，再把apr-0.9.1.tar.gz解到这个目录下­，
　　并把刚生成的目录apr-0.9.1的目录名改成apr。
　　还是在webapp目录，运行以下命令：
　　# support/buildconf.sh
　　此时如果autoconf的版本低于2.52的话会报错退出，所以必须先安装autoconf-2.52。
　　当命令成功结束后会在当前目录下生成configure文件。
　　依次运行以下命令：

　　# ./configure --with-apxs=/usr/local/apache/bin/apxs
　　# make
　　# cp apache-2.0/mod_webapp.so /usr/local/apache/modules

　　现在mod_webapp.so已经制作好了，并已经拷贝到apache的modules目录下。
　　编辑apache的配置文件，在最后加上如下几行：
　　＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
　　LoadModule webapp_module modules/mod_webapp.so
　　WebAppConnection Connector warp localhost:8008
　　WebAppDeploy examples Connector /examples
　　＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

　　运行以下命令：
　　# /usr/local/apache/bin/apachectl configtest

如果出现错误说你的apache的httpd.conf有问题后面的错误是"inviad virual host"

就说明你的httpd.conf的ServerName没有设，把ServerName前面的"#"去掉就可以了！（这是差了好多资料才得到的答案，我也是在这­儿困惑了好多天了）

　　只要出现“Syntax OK”就表明mod_webapp.so已经安装成功了。
　　启动apache
　　# /usr/local/apache/bin/apachectl start
　　访问http://localhost/examples 就可以看到tomcat的例子程序了。

注意：一定要先启动tomcat 然后再重新启动apache!

三、虚拟主机下的配置、管理和应用

　　下面以一个例子来说明虚拟主机如何同时使用Apache与Tomcat4

　　虚拟主机host1的目录结构如下所示：

　　/www　　　　　　　　　　　　　　　
　　　|---host1　　虚拟主机host1的主目录
　　　|　　|--htdocs 　普通根目录：用于显示静态页面或php程序
　　　|　　|----logs　　apache访问日志
　　　|　　|----webapps java应用目录（新加，与tomcat的webapps目录无任何关联）
　　　|　　　　　|--ROOT　jsp根目录：用于显示jsp页面程序
　　　|　　　　　|----jive　一套java应用实例
　　　|---host2　　　虚拟主机host2的主目录
　　............

　　原来的apache的配置文件是这样配置的：

　　＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
　　NameVirtualHost xxx.xxx.xxx.xxx

　　< VirtualHost xxx.xxx.xxx.xxx >
　　ServerName host1.mydomain.com
　　 ServerAdmin webmas...@mydomain.com
　　 DocumentRoot /www/host1/htdocs
　　 ErrorLog /www/host1/logs/error_log
　　CustomLog /www/host1/logs/access_log common
　　< /VirtualHost >
　　.............

　　＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

　　现在要让虚拟主机host1能同时使用Apache与Tomcat4，需要做如下配置：

　　1、编辑tomcat的配置文件server.xml，在最后的部分做如下修改：

　　＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
　　< !-- Define an Apache-Connector Service -- >

　　< Service name="Tomcat-Apache" >

　　< Connector className="org.apache.catalina.connector.warp.WarpConnector"
　　port="8008" minProcessors="5" maxProcessors="75"
　　enableLookups="true" appBase="webapps"
　　acceptCount="10" debug="0"/ >

< Engine className="org.apache.catalina.connector.warp.WarpEngine"
　　name="Apache" debug="0" >

　　< Logger className="org.apache.catalina.logger.FileLogger"
　　prefix="apache_log." suffix=".txt"
timestamp="true"/ >

　　< Realm className="org.apache.catalina.realm.MemoryRealm" / >

< !-- 下面是新加的内容 -- >

　　< Host name="host1.mydomain.com" debug="0" appBase="/www/host1/webapps"
uppackWars="true" autoDeploy="true" >
　　< Context path="" docBase="ROOT" debug="0"/ >
< !-- 下面套用的是tomcat自带的管理页面，在虚拟主机下也可使用 -- >
< Context path="/manager" debug="0" privileged="true"
　　docBase="/opt/tomcat/server/webapps/manager"/ >
　　< Context path="/jive" docBase="jive" debug="0"
reloadable="true" crossContext="true"/ >
　　< Logger className="org.apache.catalina.logger.FileLogger"
prefix="host1_log." suffix=".txt"
　　timestamp="true"/ >
　　< /Host >

< !-- 新加内容结束 -- >

< /Engine >

　　< /Service >
　　＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
　　2、编辑tomcat的管理权限文件tomcat-users.xml，在中间加一行：
< user username="myname" password="mypasswd" roles="standard,manager"/ >
　　3、编辑apache的配置文件，做如下修改
　　＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
　　LoadModule webapp_module libexec/mod_webapp.so
　　AddModule mod_webapp.c
　　WebAppConnection warpConnection warp localhost:8008
　　NameVirtualHost xxx.xxx.xxx.xxx
　　< VirtualHost xxx.xxx.xxx.xxx >
　　ServerName host1.mydomain.com
　　 ServerAdmin webmas...@mydomain.com
　　 DocumentRoot /www/host1/htdocs
　　 ErrorLog /www/host1/logs/error_log
　　 CustomLog /www/host1/logs/access_log common

　　 WebAppDeploy ROOT warpConnection /

　　#注：此行的作用是把ROOT目录作为虚拟主机URL的根，并使前面定义的根htdocs失效。
　　#但如果不想整个虚拟主机都使用jsp页面程序，而想使用大量静态页面或php程序的话，
　　#就要使用下面这行，并把所有的静态页面和php程序放在htdocs目录下。
　　# WebAppDeploy ROOT warpConnection /jsp

　　 WebAppDeploy manager warpConnection /manager
　　WebAppDeploy jive warpConnection /jive
　　#在server.xml里每定义一个都要在这里加一条WebAppDeploy。

　　< /VirtualHost >
　　＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

　　4、将tomcat用户设成/www/host1/webapps以下所有目录文件的属主。

　　要注意的是，以后如果想上传或改动该目录以下的文件，都要将其属主改成tomcat。
　　（如果一直是以root身份运行tomcat，这步可以省略。）

　　# chown -R tomcat:tomcat /www/host1/webapps
　　5、重起tomcat：
　　# su - tomcat -c "/opt/tomcat/bin/shutdown.sh"
　　# su - tomcat -c "/opt/tomcat/bin/startup.sh"
　　6、重起apache：
　　/usr/local/apache/bin/apachectl restart

　　此时访问http://host1.mydomain.com/manager/html 会提示输入密码，在输入正确的 myname和mypasswd后，就会看到“Tomcat Web Application Manager”的页面，里面的 Application Path已经是虚拟主机里配置的信息了，并可以对其进行管理。
　　到此虚拟主机下的配置和管理就全部完成，剩下的事情就是测试和应用了。在上面的例子
　　里我们已经安装了jive，经测试已经可以正常运行

作者：廖雪峰

作者简介

廖雪峰，软件工程师，现从事J2EE开发，您可以通过asklxf@163.com与他联系。

正文

java.util包中包含了一系列重要的集合类。本文将从分析源码入手，深入研究一个集合类的内部结构，以及遍历集合的迭代模式的源码实现内幕。

下面我们先简单讨论一个根接口Collection，然后分析一个抽象类AbstractList和它的对应Iterator接口，并仔细研究迭代子模式的实现原理。

本文讨论的源代码版本是JDK 1.4.2，因为JDK 1.5在java.util中使用了很多泛型代码，为了简化问题，所以我们还是讨论1.4版本的代码。

集合类的根接口Collection

Collection接口是所有集合类的根类型。它的一个主要的接口方法是：

    boolean add(Object c)

add()方法将添加一个新元素。注意这个方法会返回一个boolean，但是返回值不是表示添加成功与否。仔细阅读doc可以看到，Collection规定：如果一个集合拒绝添加这个元素，无论任何原因，都必须抛出异常。这个返回值表示的意义是add()方法执行后，集合的内容是否改变了（就是元素有无数量，位置等变化），这是由具体类实现的。即：如果方法出错，总会抛出异常；返回值仅仅表示该方法执行后这个Collection的内容有无变化。

类似的还有：

    boolean addAll(Collection c);
    boolean remove(Object o);
    boolean removeAll(Collection c);
    boolean remainAll(Collection c);

Object[] toArray()方法很简单，把集合转换成数组返回。Object[] toArray(Object[] a)方法就有点复杂了，首先，返回的Object[]仍然是把集合的所有元素变成的数组，但是类型和参数a的类型是相同的，比如执行：

    String[] o = (String[])c.toArray(new String[0]);

得到的o实际类型是String[]。

其次，如果参数a的大小装不下集合的所有元素，返回的将是一个新的数组。如果参数a的大小能装下集合的所有元素，则返回的还是a，但a的内容用集合的元素来填充。尤其要注意的是，如果a的大小比集合元素的个数还多，a后面的部分全部被置为null。

最后一个最重要的方法是iterator()，返回一个Iterator（迭代子），用于遍历集合的所有元素。

用Iterator模式实现遍历集合

Iterator模式是用于遍历集合类的标准访问方法。它可以把访问逻辑从不同类型的集合类中抽象出来，从而避免向客户端暴露集合的内部结构。

例如，如果没有使用Iterator，遍历一个数组的方法是使用索引：

    for(int i=0; i<array.size(); i++) { ... get(i) ... }

而访问一个链表（LinkedList）又必须使用while循环：

    while((e=e.next())!=null) { ... e.data() ... }

以上两种方法客户端都必须事先知道集合的内部结构，访问代码和集合本身是紧耦合，无法将访问逻辑从集合类和客户端代码中分离出来，每一种集合对应一种遍历方法，客户端代码无法复用。

更恐怖的是，如果以后需要把ArrayList更换为LinkedList，则原来的客户端代码必须全部重写。

为解决以上问题，Iterator模式总是用同一种逻辑来遍历集合：

    for(Iterator it = c.iterater(); it.hasNext(); ) { ... }

奥秘在于客户端自身不维护遍历集合的"指针"，所有的内部状态（如当前元素位置，是否有下一个元素）都由Iterator来维护，而这个Iterator由集合类通过工厂方法生成，因此，它知道如何遍历整个集合。

客户端从不直接和集合类打交道，它总是控制Iterator，向它发送"向前"，"向后"，"取当前元素"的命令，就可以间接遍历整个集合。

首先看看java.util.Iterator接口的定义：

    public interface Iterator {
        boolean hasNext();
        Object next();
        void remove();
    }

依赖前两个方法就能完成遍历，典型的代码如下：

    for(Iterator it = c.iterator(); it.hasNext(); ) {
        Object o = it.next();
        // 对o的操作...
    }

在JDK1.5中，还对上面的代码在语法上作了简化：

    // Type是具体的类型，如String。
    for(Type t : c) {
        // 对t的操作...
    }

每一种集合类返回的Iterator具体类型可能不同，Array可能返回ArrayIterator，Set可能返回SetIterator，Tree可能返回TreeIterator，但是它们都实现了Iterator接口，因此，客户端不关心到底是哪种Iterator，它只需要获得这个Iterator接口即可，这就是面向对象的威力。

Iterator源码剖析

让我们来看看AbstracyList如何创建Iterator。首先AbstractList定义了一个内部类（inner class）：

    private class Itr implements Iterator {
        ...
    }

而iterator()方法的定义是：

    public Iterator iterator() {
        return new Itr();
    }

因此客户端不知道它通过Iterator it = a.iterator();所获得的Iterator的真正类型。

现在我们关心的是这个申明为private的Itr类是如何实现遍历AbstractList的：

    private class Itr implements Iterator {
        int cursor = 0;
        int lastRet = -1;
        int expectedModCount = modCount;
    }

Itr类依靠3个int变量（还有一个隐含的AbstractList的引用）来实现遍历，cursor是下一次next()调用时元素的位置，第一次调用next()将返回索引为0的元素。lastRet记录上一次游标所在位置，因此它总是比cursor少1。

变量cursor和集合的元素个数决定hasNext()：

    public boolean hasNext() {
        return cursor != size();
    }

方法next()返回的是索引为cursor的元素，然后修改cursor和lastRet的值：

    public Object next() {
        checkForComodification();
        try {
            Object next = get(cursor);
            lastRet = cursor++;
            return next;
        } catch(IndexOutOfBoundsException e) {
            checkForComodification();
            throw new NoSuchElementException();
        }
    }

expectedModCount表示期待的modCount值，用来判断在遍历过程中集合是否被修改过。AbstractList包含一个modCount变量，它的初始值是0，当集合每被修改一次时（调用add，remove等方法），modCount加1。因此，modCount如果不变，表示集合内容未被修改。

Itr初始化时用expectedModCount记录集合的modCount变量，此后在必要的地方它会检测modCount的值：

    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }

如果modCount与一开始记录在expectedModeCount中的值不等，说明集合内容被修改过，此时会抛出ConcurrentModificationException。

这个ConcurrentModificationException是RuntimeException，不要在客户端捕获它。如果发生此异常，说明程序代码的编写有问题，应该仔细检查代码而不是在catch中忽略它。

但是调用Iterator自身的remove()方法删除当前元素是完全没有问题的，因为在这个方法中会自动同步expectedModCount和modCount的值：

    public void remove() {
        ...
        AbstractList.this.remove(lastRet);
        ...
        // 在调用了集合的remove()方法之后重新设置了expectedModCount：
        expectedModCount = modCount;
        ...
    }

要确保遍历过程顺利完成，必须保证遍历过程中不更改集合的内容（Iterator的remove()方法除外），因此，确保遍历可靠的原则是只在一个线程中使用这个集合，或者在多线程中对遍历代码进行同步。

最后给个完整的示例：

    Collection c = new ArrayList();
    c.add("abc");
    c.add("xyz");
    for(Iterator it = c.iterator(); it.hasNext(); ) {
        String s = (String)it.next();
        System.out.println(s);
    }

如果你把第一行代码的ArrayList换成LinkedList或Vector，剩下的代码不用改动一行就能编译，而且功能不变，这就是针对抽象编程的原则：对具体类的依赖性最小。