更多精彩请到 http://www.139ya.com
Windows查看端口被某个进程占用方法 : http://hi.baidu.com/haohaopc/blog/item/d757a44b2df19ff382025c9e.html
在命令提示符下运行netstat -ano 后面即可显示出相应的PID号，然后再到任务管理器看查看相应的PID号进程即可。
Thursday, April 30, 2009
Wednesday, April 29, 2009
WebService 的一些基本概念
更多精彩请到 http://www.139ya.com
转自： http://blog.csdn.net/dragondwy/archive/2009/01/06/3722397.aspx
Endpoint, Namespace,RPC/Document Type
http://www.ttdev.com/SimpleService 这个webservice全名就是所谓的"endpoint"
RPC 型的Web Service 方法定义
Document 类型Webservice
注释：
http://ttdev.com/ss 就是namespace, 并无特别意义，只需要global 唯一.
namespace 不用于endpoint, endpoint 是一个存在的location;而namespace就是一个表示unique ID.
可以任意移动webservice的位置，改变Server，也就是说变更endpoint；但是方法(operation)的namespace不可以改变。
不同点在哪？ 最大不同就是RPC不能通过Schema 来校验，而document 类型是可以的。因此document 类型webservice成为主流 。
"WS-I (web services interoperability organization)" 组织规定只使用document类型 web services。
Port type
事实上，一个Web service 并不直接包含一组operation(方法)。方法是被组成一个或多个"Port Types"。
一个Port type 类似java 类，每个operation 类似java class中的静态方法。
比如，一个web service中，把所有string相关操作组成 stringUtil Port type, 把日期相关的操作组成dateUtil Port Type.
所有 port type的命名必须是QName. （QName 就是需要有 namespace和localname的全名称， 见上篇的图示）
Binding
一个 port type 允许使用不同的信息格式访问，比如SOAP(Simple Object Access Protocal)或
普通文本格式(plain text fomat):
concat(s1='abc', s2='123')
除了信息格式，每个port type还允许使用信息通过HTTP Post 请求或者 通过 email方式传送。
因此，每个被支持的信息格式和信息传送方式组合，就叫做 binding.
最常见的binding就是 SOAP+HTTP.
Port
假如很多人使用你的web service,你决定把你的web service部署到3台机器上(C1,C2,C3)。
部署策略为：采用binding1于C1,C2,C3 机器上；采用binding2于C3机器上.
此时，我们就说，你一共有四个port, 其中3个port使用用binding1, 1个port使用binding2.
看图理解的快
需要注意的是, 每个port的方法实现可以使用不同的软件，语言，比如port1用 java 写，port2用C#写，都无所谓，但都必须实现port type 中的operation,已经binding1定义的
message format 和传输方式。
因此，为了表达这个部署的结构信息，在Web service 接口定义中port的信息
Target Namespace
上面2篇中的例子看到，在web service中，无论是operation 名,还是port type的名字，都用了同一个namespace.
默认情况下，一个web service使用单一namespace来命名各种对象。这个namespace，称为web service 的Target Namespace
Namespace 的命名必须是URI (Uniform Resource Identifer), 而URI有分2种类型.
Web servie 中的target namespace, 使用两种URI都可以。
WSDL
上面图中的内容已经充分的描述出一个web service 设计。那么这中描述Web service的语言，就叫做WSDL(Web Services Description Language)
总结
Web service 是平台无关的，语言无关的，可以通过internet访问。
一个 Web service 具有一个或多个ports.每个port 是指部署在某个网络地址上的一个binding.
这个网络地址叫做endpoint. 一个binding是指某个port type使用的特有信息格式和特有的传输协议的结合。
一个port type可以包含一个或多个operations. 每个operation 可以有输入信息(方法调用和输入参数)和输出信息(返回值)。
每个信息包含一个或多个parts. 每个part都是一个在web service的schema中定义好的element。
所有内容通过WSDL描述。
如果要调用以讹RPC 类型的web service, 需要创建XML element, 其中包含operation 名字，所有输入信息(part)的element.等内容。
而调用document 类型的web service，只需要发送一个 输入信息part 的内容即可。
因为RPC类型 web service中的XML element没定义在任何schema中，因此没有校验机制。
所以document 类型的web service是主流，为了更好地协作性考虑，应该使用这种类型。
web service，每个ports,bindings, port types, operations 都有一个QName作为唯一标识符。
一个QName包含 local part和 XML namespace两部分。
一个XML namespace是一个全局唯一URI.
默认情况下，web service中所有这些对象的命名都是用单一的Target namespace.
URI有两种类型：URL 和 URN.
URN 具有这样的格式 urn::.
XML namespace可以任意使用URL和URN格式，他们的区别是，URL 往往表示某个对象的位置，而URN就是一个纯粹的对象标志符号。
You can use either as an XML namespace. The only
difference is that a URL is suggesting that it is the location of an object, while a
URN is purely an id of the object.
转自： http://blog.csdn.net/dragondwy/archive/2009/01/06/3722397.aspx
Endpoint, Namespace,RPC/Document Type
http://www.ttdev.com/SimpleService 这个webservice全名就是所谓的"endpoint"
RPC 型的Web Service 方法定义
Document 类型Webservice
注释：
http://ttdev.com/ss 就是namespace, 并无特别意义，只需要global 唯一.
namespace 不用于endpoint, endpoint 是一个存在的location;而namespace就是一个表示unique ID.
可以任意移动webservice的位置，改变Server，也就是说变更endpoint；但是方法(operation)的namespace不可以改变。
不同点在哪？ 最大不同就是RPC不能通过Schema 来校验，而document 类型是可以的。因此document 类型webservice成为主流 。
"WS-I (web services interoperability organization)" 组织规定只使用document类型 web services。
Port type
事实上，一个Web service 并不直接包含一组operation(方法)。方法是被组成一个或多个"Port Types"。
一个Port type 类似java 类，每个operation 类似java class中的静态方法。
比如，一个web service中，把所有string相关操作组成 stringUtil Port type, 把日期相关的操作组成dateUtil Port Type.
所有 port type的命名必须是QName. （QName 就是需要有 namespace和localname的全名称， 见上篇的图示）
Binding
一个 port type 允许使用不同的信息格式访问，比如SOAP(Simple Object Access Protocal)或
普通文本格式(plain text fomat):
concat(s1='abc', s2='123')
除了信息格式，每个port type还允许使用信息通过HTTP Post 请求或者 通过 email方式传送。
因此，每个被支持的信息格式和信息传送方式组合，就叫做 binding.
最常见的binding就是 SOAP+HTTP.
Port
假如很多人使用你的web service,你决定把你的web service部署到3台机器上(C1,C2,C3)。
部署策略为：采用binding1于C1,C2,C3 机器上；采用binding2于C3机器上.
此时，我们就说，你一共有四个port, 其中3个port使用用binding1, 1个port使用binding2.
看图理解的快
需要注意的是, 每个port的方法实现可以使用不同的软件，语言，比如port1用 java 写，port2用C#写，都无所谓，但都必须实现port type 中的operation,已经binding1定义的
message format 和传输方式。
因此，为了表达这个部署的结构信息，在Web service 接口定义中port的信息
Target Namespace
上面2篇中的例子看到，在web service中，无论是operation 名,还是port type的名字，都用了同一个namespace.
默认情况下，一个web service使用单一namespace来命名各种对象。这个namespace，称为web service 的Target Namespace
Namespace 的命名必须是URI (Uniform Resource Identifer), 而URI有分2种类型.
Web servie 中的target namespace, 使用两种URI都可以。
| URL | http://blog.csdn.net/dragondwy |
| URN | urn: |
WSDL
上面图中的内容已经充分的描述出一个web service 设计。那么这中描述Web service的语言，就叫做WSDL(Web Services Description Language)
总结
Web service 是平台无关的，语言无关的，可以通过internet访问。
一个 Web service 具有一个或多个ports.每个port 是指部署在某个网络地址上的一个binding.
这个网络地址叫做endpoint. 一个binding是指某个port type使用的特有信息格式和特有的传输协议的结合。
一个port type可以包含一个或多个operations. 每个operation 可以有输入信息(方法调用和输入参数)和输出信息(返回值)。
每个信息包含一个或多个parts. 每个part都是一个在web service的schema中定义好的element。
所有内容通过WSDL描述。
如果要调用以讹RPC 类型的web service, 需要创建XML element, 其中包含operation 名字，所有输入信息(part)的element.等内容。
而调用document 类型的web service，只需要发送一个 输入信息part 的内容即可。
因为RPC类型 web service中的XML element没定义在任何schema中，因此没有校验机制。
所以document 类型的web service是主流，为了更好地协作性考虑，应该使用这种类型。
web service，每个ports,bindings, port types, operations 都有一个QName作为唯一标识符。
一个QName包含 local part和 XML namespace两部分。
一个XML namespace是一个全局唯一URI.
默认情况下，web service中所有这些对象的命名都是用单一的Target namespace.
URI有两种类型：URL 和 URN.
URN 具有这样的格式 urn:
XML namespace可以任意使用URL和URN格式，他们的区别是，URL 往往表示某个对象的位置，而URN就是一个纯粹的对象标志符号。
You can use either as an XML namespace. The only
difference is that a URL is suggesting that it is the location of an object, while a
URN is purely an id of the object.
jmock
更多精彩请到 http://www.139ya.com
JMock cookbook : http://thinking.5ming.org.cn/tag/mock/
jmock 2 使用总结 : http://fly-hyp.javaeye.com/blog/203094
jmock 2 使用入门 : http://superleo.javaeye.com/blog/143493
运用JMock来完成孤立测试 : http://www.qqgb.com/Program/Java/javadoc/javalib/Program_155684.html
jmock 使用入门 : http://tech.it168.com/m/2008-04-22/200804222221319.shtml
使用模拟对象（Mock Object）技术进行测试驱动开发 : http://www.ibm.com/developerworks/cn/java/j-lo-mockobject/index.html
运用JMock来完成孤立测试 : http://blog.csdn.net/icecloud/archive/2004/04/19/7802.aspx
使用jMock辅助单元测试 : http://blog.csdn.net/icecloud/archive/2004/04/19/7802.aspx
JMock cookbook : http://thinking.5ming.org.cn/tag/mock/
jmock 2 使用总结 : http://fly-hyp.javaeye.com/blog/203094
jmock 2 使用入门 : http://superleo.javaeye.com/blog/143493
运用JMock来完成孤立测试 : http://www.qqgb.com/Program/Java/javadoc/javalib/Program_155684.html
jmock 使用入门 : http://tech.it168.com/m/2008-04-22/200804222221319.shtml
使用模拟对象（Mock Object）技术进行测试驱动开发 : http://www.ibm.com/developerworks/cn/java/j-lo-mockobject/index.html
运用JMock来完成孤立测试 : http://blog.csdn.net/icecloud/archive/2004/04/19/7802.aspx
使用jMock辅助单元测试 : http://blog.csdn.net/icecloud/archive/2004/04/19/7802.aspx
Tuesday, April 28, 2009
JUnit
更多精彩请到 http://www.139ya.com
JUnit 学习笔记: http://caterpillar.onlyfun.net/Gossip/JUnit/JUnitGossip.htm
JUnit设计模式分析 : http://luogankun.javaeye.com/category/60169
junit 实战: http://www.iceshi.com/html/40/category-catid-140.html
JUnit测试框架使用介绍 : http://zhangjunhd.blog.51cto.com/113473/132553
测试是否抛出正确的异常 : http://book.csdn.net/bookfiles/153/1001536549.shtml
JUnit 学习笔记: http://caterpillar.onlyfun.net/Gossip/JUnit/JUnitGossip.htm
JUnit设计模式分析 : http://luogankun.javaeye.com/category/60169
junit 实战: http://www.iceshi.com/html/40/category-catid-140.html
JUnit测试框架使用介绍 : http://zhangjunhd.blog.51cto.com/113473/132553
测试是否抛出正确的异常 : http://book.csdn.net/bookfiles/153/1001536549.shtml
JUnit入门
更多精彩请到 http://www.139ya.com
一、简介
JUnit是一个开源的java单元测试框架。在1997年，由 Erich Gamma 和 Kent Beck 开发完成。这两个牛人中 Erich Gamma 是 GOF 之一；Kent Beck 则在 XP 中有重要的贡献（你觉得眼熟一点都不奇怪）。
正如常言道：“麻雀虽小，五脏俱全。” JUnit设计的非常小巧，但是功能却非常强大。
下面是JUnit一些特性的总结：
1) 提供的API可以让你写出测试结果明确的可重用单元测试用例
2) 提供了三种方式来显示你的测试结果，而且还可以扩展
3) 提供了单元测试用例成批运行的功能
4) 超轻量级而且使用简单，没有商业性的欺骗和无用的向导
5) 整个框架设计良好，易扩展
对不同性质的被测对象，如Class，Jsp，Servlet，Ejb等，Junit有不同的使用技巧。由于本文的性质，以下仅以Class测试为例。
二、下载
点击http://www.junit.org可以下载到最新版本的JUnit，本文使用的为3.8.1版。至于安装或者配置之类，你只需要轻松的将下载下来的压缩包中的jar文件，放到你工程的classpath中就可以了。
这样，你的系统中就可以使用JUnit编写单元测试代码了（是不是很简单）！
三、HelloWorld
记得在几乎每本语言教学书上都能找到HelloWorld这个入门代码。今天在这里，我们也从一个简单到根本不用单元测试的例子入手。这是一个只会做两数加减的超级简单的计算器（小学一年级必备极品）。代码如下：
public class SampleCalculator
{
public int add(int augend , int addend)
{
return augend + addend ;
}
public int subtration(int minuend , int subtrahend)
{
return minuend - subtrahend ;
}
}
将上面的代码编译通过。下面就是我为上面程序写的一个单元测试用例：
//请注意这个程序里面类名和方法名的特征
import junit.framework.TestCase;
public class TestSample extends TestCase
{
public void testAdd()
{
SampleCalculator calculator = new SampleCalculator();
int result = calculator.add(50 , 20);
assertEquals(70 , result);
}
public void testSubtration()
{
SampleCalculator calculator = new SampleCalculator();
int result = calculator.subtration(50 , 20);
assertEquals(30 , result);
}
}
好了，在DOS命令行里面输入javac TestSample.java 将测试类编译通过。然后再输入 java junit.swingui.TestRunner TestSample 运行测试类，你会看到如下的窗口。
绿色说明单元测试通过，没有错误产生；如果是红色的，则就是说测试失败了。这样一个简单的单元测试就完成了.
按照框架规定：编写的所有测试类，必须继承自junit.framework.TestCase类；里面的测试方法，命名应该以Test开头，必须是 public void 而且不能有参数；而且为了测试查错方便，尽量一个TestXXX方法对一个功能单一的方法进行测试；使用assertEquals等 junit.framework.TestCase中的断言方法来判断测试结果正确与否。
你可以对比着上面测试类中的实现来体会下规定——很简单！而且你在这个测试类中有加入多少个测试方法，就会运行多少个测试方法。
四、向前一步
学完了HelloWorld，你已经可以编写标准的单元测试用例了。但是还有一些细节，这里还要说明一下。不要急，很快的！
另外你是否注意到，上面弹出窗口的一个细节，在绿条下面有Errors、Failures统计。这两者有何区别呢？
Failures作为单元测试所期望发生的错误，它预示你的代码有bug，不过也可能是你的单元测试代码有逻辑错误（注意是逻辑错误）。Errors不是你所期待的，发生了Error你可以按照下面的顺序来检查：
检查测试所需的环境，如：数据库连接
检查单元测试代码
检查你的系统代码
五、成批运行test case
这是前面提到的JUnit特性之一。它方便于系统单元测试的成批运行。使用起来也是非常简单，先看下使用代码：
import junit.framework.Test;
import junit.framework.TestSuite;
public class TestAll{
public static Test suite(){
TestSuite suite = new TestSuite("TestSuite Test");
suite.addTestSuite( TestSample.class);
return suite;
}
}
这个测试程序的编译、运行，和上面TestSample的方式是一样的。
javac TestAll.java
java junit.swingui.TestRunner TestAll
怎么样？这样你在suite方法里面添加几个TestCase就会运行几个，而且它也可以添加TestSuite来将小一点的集合加入大的集合中来，方便了对于不断增加的TestCase的管理和维护。
你觉得suite方法的作用是不是于java应用程序的main很类似？并且这里的suite必须严格遵守上面的写法！
一、简介
JUnit是一个开源的java单元测试框架。在1997年，由 Erich Gamma 和 Kent Beck 开发完成。这两个牛人中 Erich Gamma 是 GOF 之一；Kent Beck 则在 XP 中有重要的贡献（你觉得眼熟一点都不奇怪）。
正如常言道：“麻雀虽小，五脏俱全。” JUnit设计的非常小巧，但是功能却非常强大。
下面是JUnit一些特性的总结：
1) 提供的API可以让你写出测试结果明确的可重用单元测试用例
2) 提供了三种方式来显示你的测试结果，而且还可以扩展
3) 提供了单元测试用例成批运行的功能
4) 超轻量级而且使用简单，没有商业性的欺骗和无用的向导
5) 整个框架设计良好，易扩展
对不同性质的被测对象，如Class，Jsp，Servlet，Ejb等，Junit有不同的使用技巧。由于本文的性质，以下仅以Class测试为例。
二、下载
点击http://www.junit.org可以下载到最新版本的JUnit，本文使用的为3.8.1版。至于安装或者配置之类，你只需要轻松的将下载下来的压缩包中的jar文件，放到你工程的classpath中就可以了。
这样，你的系统中就可以使用JUnit编写单元测试代码了（是不是很简单）！
三、HelloWorld
记得在几乎每本语言教学书上都能找到HelloWorld这个入门代码。今天在这里，我们也从一个简单到根本不用单元测试的例子入手。这是一个只会做两数加减的超级简单的计算器（小学一年级必备极品）。代码如下：
public class SampleCalculator
{
public int add(int augend , int addend)
{
return augend + addend ;
}
public int subtration(int minuend , int subtrahend)
{
return minuend - subtrahend ;
}
}
将上面的代码编译通过。下面就是我为上面程序写的一个单元测试用例：
//请注意这个程序里面类名和方法名的特征
import junit.framework.TestCase;
public class TestSample extends TestCase
{
public void testAdd()
{
SampleCalculator calculator = new SampleCalculator();
int result = calculator.add(50 , 20);
assertEquals(70 , result);
}
public void testSubtration()
{
SampleCalculator calculator = new SampleCalculator();
int result = calculator.subtration(50 , 20);
assertEquals(30 , result);
}
}
好了，在DOS命令行里面输入javac TestSample.java 将测试类编译通过。然后再输入 java junit.swingui.TestRunner TestSample 运行测试类，你会看到如下的窗口。
绿色说明单元测试通过，没有错误产生；如果是红色的，则就是说测试失败了。这样一个简单的单元测试就完成了.
按照框架规定：编写的所有测试类，必须继承自junit.framework.TestCase类；里面的测试方法，命名应该以Test开头，必须是 public void 而且不能有参数；而且为了测试查错方便，尽量一个TestXXX方法对一个功能单一的方法进行测试；使用assertEquals等 junit.framework.TestCase中的断言方法来判断测试结果正确与否。
你可以对比着上面测试类中的实现来体会下规定——很简单！而且你在这个测试类中有加入多少个测试方法，就会运行多少个测试方法。
四、向前一步
学完了HelloWorld，你已经可以编写标准的单元测试用例了。但是还有一些细节，这里还要说明一下。不要急，很快的！
另外你是否注意到，上面弹出窗口的一个细节，在绿条下面有Errors、Failures统计。这两者有何区别呢？
Failures作为单元测试所期望发生的错误，它预示你的代码有bug，不过也可能是你的单元测试代码有逻辑错误（注意是逻辑错误）。Errors不是你所期待的，发生了Error你可以按照下面的顺序来检查：
检查测试所需的环境，如：数据库连接
检查单元测试代码
检查你的系统代码
五、成批运行test case
这是前面提到的JUnit特性之一。它方便于系统单元测试的成批运行。使用起来也是非常简单，先看下使用代码：
import junit.framework.Test;
import junit.framework.TestSuite;
public class TestAll{
public static Test suite(){
TestSuite suite = new TestSuite("TestSuite Test");
suite.addTestSuite( TestSample.class);
return suite;
}
}
这个测试程序的编译、运行，和上面TestSample的方式是一样的。
javac TestAll.java
java junit.swingui.TestRunner TestAll
怎么样？这样你在suite方法里面添加几个TestCase就会运行几个，而且它也可以添加TestSuite来将小一点的集合加入大的集合中来，方便了对于不断增加的TestCase的管理和维护。
你觉得suite方法的作用是不是于java应用程序的main很类似？并且这里的suite必须严格遵守上面的写法！
JUnit和单元测试入门简介
更多精彩请到 http://www.139ya.com
1、几个相关的概念
白盒测试——把测试对象看作一个打开的盒子，程序内部的逻辑结构和其他信息对测试人员是公开的。
回归测试——软件或环境的修复或更正后的“再测试”，自动测试工具对这类测试尤其有用。
单元测试——是最小粒度的测试，以测试某个功能或代码块。一般由程序员来做，因为它需要知道内部程序设计和编码的细节。
JUnit ——是一个开发源代码的Java测试框架，用于编写和运行可重复的测试。他是用于单元测试框架体系xUnit的一个实例（用于java语言）。主要用于白盒测试，回归测试。
2、单元测试概述
2.1、单元测试的好处
A、提高开发速度——测试是以自动化方式执行的，提升了测试代码的执行效率。
B、提高软件代码质量——它使用小版本发布至集成，便于实现人员除错。同时引入重构概念，让代码更干净和富有弹性。
C、提升系统的可信赖度——它是回归测试的一种。支持修复或更正后的“再测试”，可确保代码的正确性。
2．2、单元测试的针对对象
A、面向过程的软件开发针对过程。
B、面向对象的软件开发针对对象。
C、可以做类测试，功能测试，接口测试（最常用于测试类中的方法）。
2.3、单元测试工具和框架
目前的最流行的单元测试工具是xUnit系列框架，常用的根据语言不同分为JUnit（java），CppUnit（C++），DUnit （Delphi ），NUnit（.net），PhpUnit（Php ）等等。该测试框架的第一个和最杰出的应用就是由Erich Gamma （《设计模式》的作者）和Kent Beck（XP（Extreme Programming）的创始人 ）提供的开放源代码的JUnit。
3.Junit入门简介
3.1、JUnit的好处和JUnit单元测试编写原则
好处：
A、可以使测试代码与产品代码分开。
B、针对某一个类的测试代码通过较少的改动便可以应用于另一个类的测试。
C、易于集成到测试人员的构建过程中，JUnit和Ant的结合可以实施增量开发。
D、JUnit是公开源代码的，可以进行二次开发。
C、可以方便地对JUnit进行扩展。
编写原则：
A、是简化测试的编写，这种简化包括测试框架的学习和实际测试单元的编写。
B、是使测试单元保持持久性。
C、是可以利用既有的测试来编写相关的测试。
3.2、JUnit的特征
A、使用断言方法判断期望值和实际值差异，返回Boolean值。
B、测试驱动设备使用共同的初始化变量或者实例。
C、测试包结构便于组织和集成运行。
D、支持图型交互模式和文本交互模式。
3.3、JUnit框架组成
A、对测试目标进行测试的方法与过程集合，可称为测试用例(TestCase)。
B、测试用例的集合，可容纳多个测试用例(TestCase)，将其称作测试包(TestSuite)。
C、测试结果的描述与记录。(TestResult) 。
D、测试过程中的事件监听者(TestListener)。
E、每一个测试方法所发生的与预期不一致状况的描述，称其测试失败元素(TestFailure)
F、JUnit Framework中的出错异常（AssertionFailedError）。
JUnit框架是一个典型的Composite模式：TestSuite可以容纳任何派生自Test的对象；当调用TestSuite对象的run()方法是，会遍历自己容纳的对象，逐个调用它们的run()方法。（可参考《程序员》2003-6期）。
3.4、JUnit的安装和配置
JUnit安装步骤分解：
在http://download.sourceforge.net/junit/中下载JUnit包并将Junit压缩包解压到一个物理目录中（例如C：＼Junit3.8.1）。
记录Junit.jar文件所在目录名（例如C：＼Junit3.8.1\Junit.jar）。
进入操作系统（以Windows2000操作系统为准），按照次序点击“开始 设置 控制面板”。
在控制面板选项中选择“系统”，点击“环境变量”，在“系统变量”的“变量”列表框中选择“CLASS-PATH”关键字（不区分大小写），如果该关键字不存在则添加。
双击“CLASS-PATH”关键字添加字符串“C:＼Junit3.8.1\Junti.jar”(注意，如果已有别的字符串请在该字符串的字符结尾加上分号“；”)，这样确定修改后Junit就可以在集成环境中应用了。
对于IDE环境，对于需要用到的JUnit的项目增加到lib中，其设置不同的IDE有不同的设置 。
3.5、JUnit中常用的接口和类
Test接口——运行测试和收集测试结果
Test接口使用了Composite设计模式，是单独测试用例 （TestCase），聚合测试模式（TestSuite）及测试扩展（TestDecorator）的共同接口。
它的public int countTestCases（）方法，它来统计这次测试有多少个TestCase，另外一个方法就是public void run（ TestResult ），TestResult是实例接受测试结果， run方法执行本次测试。
TestCase抽象类——定义测试中固定方法
TestCase 是Test接口的抽象实现，（不能被实例化，只能被继承）其构造函数TestCase(string name)根据输入的测试名称name创建一个测试实例。由于每一个TestCase在创建时都要有一个名称，若某测试失败了，便可识别出是哪个测试失败。
TestCase类中包含的setUp()、tearDown()方法。setUp()方法集中初始化测试所需的所有变量和实例，并且在依次调用测试类中的每个测试方法之前再次执行setUp()方法。tearDown()方法则是在每个测试方法之后，释放测试程序方法中引用的变量和实例。
开发人员编写测试用例时，只需继承TestCase，来完成run方法即可，然后JUnit获得测试用例，执行它的run方法，把测试结果记录在TestResult之中。
Assert静态类——一系列断言方法的集合
Assert 包含了一组静态的测试方法，用于期望值和实际值比对是否正确，即测试失败，Assert类就会抛出一个AssertionFailedError异常，JUnit测试框架将这种错误归入Failes并加以记录，同时标志为未通过测试。如果该类方法中指定一个String类型的传参则该参数将被做为 AssertionFailedError异常的标识信息，告诉测试人员改异常的详细信息。
JUnit 提供了6大类31组断言方法，包括基础断言、数字断言、字符断言、布尔断言、对象断言。
其中assertEquals（Object expcted,Object actual)内部逻辑判断使用equals()方法，这表明断言两个实例的内部哈希值是否相等时，最好使用该方法对相应类实例的值进行比较。而 assertSame（Object expected,Object actual）内部逻辑判断使用了Java运算符“==”，这表明该断言判断两个实例是否来自于同一个引用（Reference），最好使用该方法对不同类的实例的值进行比对。asserEquals(String message,String expected,String actual)该方法对两个字符串进行逻辑比对，如果不匹配则显示着两个字符串有差异的地方。ComparisonFailure类提供两个字符串的比对，不匹配则给出详细的差异字符。
TestSuite测试包类——多个测试的组合
TestSuite类负责组装多个Test Cases。待测得类中可能包括了对被测类的多个测试，而TestSuit负责收集这些测试，使我们可以在一个测试中，完成全部的对被测类的多个测试。
TestSuite类实现了Test接口，且可以包含其它的TestSuites。它可以处理加入Test时的所有抛出的异常。
TestSuite处理测试用例有6个规约（否则会被拒绝执行测试）
A 测试用例必须是公有类（Public）
B 测试用例必须继承与TestCase类
C 测试用例的测试方法必须是公有的（ Public ）
D 测试用例的测试方法必须被声明为Void
E 测试用例中测试方法的前置名词必须是test
F 测试用例中测试方法误任何传递参数
n TestResult结果类和其它类与接口
TestResult结果类集合了任意测试累加结果，通过TestResult实例传递个每个测试的Run（）方法。TestResult在执行TestCase是如果失败会异常抛出
TestListener 接口是个事件监听规约，可供TestRunner类使用。它通知listener的对象相关事件，方法包括测试开始startTest(Test test)，测试结束endTest(Test test),错误，增加异常addError(Test test,Throwable t)和增加失败addFailure(Test test,AssertionFailedError t)
TestFailure失败类是个“失败”状况的收集类，解释每次测试执行过程中出现的异常情况。其toString()方法返回“失败”状况的简要描述
3.6、JUnit一个实例
在控制台中简单的范例如下：
1、写个待测试的Triangle类，创建一个TestCase的子类ExampleTest:
2、 ExampleTest中写一个或多个测试方法，断言期望的结果(注意：以test作为待测试的方法的开头，这样这些方法可以被自动找到并被测试)
3、 ExampleTest中写一个suite()方法，它会使用反射动态的创建一个包含所有的testXxxx方法的测试套件：
4、 ExampleTest可以写setUp()、tearDown()方法，以便于在测试时初始化或销毁测试所需的所有变量和实例。（不是必须的）
5、写一个main()方法以文本运行器或其它GUI的方式方便的运行测试
6、编译ExampleTest，执行测试。
3.7、Eclipse中JUnit的使用
Eclipse自带了一个JUnit的插件，不用安装就可以在你的项目中开始测试相关的类，并且可以调试你的测试用例和被测试类。
使用步骤如下：
1、新建一个测试用例，点击“File->New->Other…菜单项，在弹出的“New”对话框中选择”Java->JUnit”,下的TestCase 或TestSuite，就进入“New JUnit TestCase”对话框
2、在“New JUnit TestCase”对话框填写相应的栏目，主要有Name（测试用例名），SuperClass（测试的超类一般是默认的 junit.framework.TestCase），Class Under Test（被测试的类），Source Folder（测试用例保存的目录），Package（测试用例包名），及是否自动生成main,setUp,tearDown方法。
3、如果点击下面的”Next>”按钮，你还可以直接勾选你想测试的被测试类的方法，Eclipse将自动生成与被选方法相应的测试方法，点击“Fishish”按钮后一个测试用例就创建好了。
4、编写完成你的测试用例后，点击“Run”按钮就可以看到运行结果了。
3.8、JUnit的扩展应用
以下罗列了些JUnit的扩展应用：
JUnit + HttpUnit=WEB功能测试工具
JUnit + hansel =代码覆盖测试工具
JUnit + abbot =界面自动回放测试工具
JUnit + dbunit =数据库测试工具
JUnit + junitperf=性能测试工具
3.9、一些使用JUnit经验
不要用TestCase的构造函数初始化，而要用setUp()和tearDown()方法。
不要依赖或假定测试运行的顺序，因为JUnit利用Vector保存测试方法。所以不同的平台会按不同的顺序从Vector中取出测试方法。
避免编写有副作用的TestCase。例如：如果随后的测试依赖于某些特定的交易数据，就不要提交交易数据。简单的回滚就可以了。
当继承一个测试类时，记得调用父类的setUp()和tearDown()方法。
将测试代码和工作代码放在一起，一边同步编译和更新。
测试类和测试方法应该有一致的命名方案。如在工作类名前加上test从而形成测试类名。
确保测试与时间无关，不要依赖使用过期的数据进行测试。导致在随后的维护过程中很难重现测试。
如果你编写的软件面向国际市场，编写测试时要考虑国际化的因素。不要仅用母语的Locale进行测试。
尽可能地利用JUnit提供地assert/fail方法以及异常处理的方法，可以使代码更为简洁。
测试要尽可能地小，执行速度快。
参考资料与附件
1. http:// www.junit.org JUnit官方网站
2. http://bbs.51cmm.com 的测试论坛
3. http://www.uml.org.cn 的软件测试专栏
4. 单元测试 《程序员》 2002年7期
5. JUnit设计模式分析 《程序员》2003年6期
6. 《软件测试和JUnit实践》
7. 附件Triangle.java 一个要测试的类
8. 附件ExampleTest.java 一个测试用例类
Triangle.java
/**
* this is Triangle class
* @author liujun
*/
public class Triangle
{
//定义三角形的三边
protected long lborderA = 0;
protected long lborderB = 0;
protected long lborderC = 0;
//构造函数
public Triangle(long lborderA,long lborderB,long lborderC)
{
this.lborderA = lborderA;
this.lborderB = lborderB;
this.lborderC = lborderC;
}
/**
* 判断是否是三角形
* 是返回ture；不是返回false
*/
public boolean isTriangle(Triangle triangle)
{
boolean isTrue = false;
//判断边界，大于0小于200，出界返回false
if((triangle.lborderA>0&&triangle.lborderA<200)
&&(triangle.lborderB>0&&triangle.lborderB<200)
&&(triangle.lborderC>0&&triangle.lborderC<200))
{
//判断两边之和大于第三边
if((triangle.lborderA<(triangle.lborderB+triangle.lborderC))
&&(triangle.lborderB<(triangle.lborderA+triangle.lborderC))
&&(triangle.lborderC<(triangle.lborderA+triangle.lborderB)))
isTrue = true;
}
return isTrue;
}
/**
* 判断三角形类型
* 等腰三角形返回字符串“等腰三角形”；
* 等边三角形返回字符串“等边三角形”；
* 其它三角形返回字符串“不等边三角形”；
*/
public String isType(Triangle triangle)
{
String strType = "";
// 判断是否是三角形
if(this.isTriangle(triangle))
{
//判断是否是等边三角形 if(triangle.lborderA==triangle.lborderB&&triangle.lborderB==triangle.lborderC)
strType = "等边三角形";
//判断是否是不等边三角形
else if((triangle.lborderA!=triangle.lborderB)&&
(triangle.lborderB!=triangle.lborderC)&&
(triangle.lborderA!=triangle.lborderC))
strType = "不等边三角形";
else
strType="等腰三角形";
}
return strType;
}
}
ExampleTest.java
import junit.framework.*;
/**
* Some tests.
*
*/
public class ExampleTest extends TestCase {
public Triangle triangle;
//初始化
protected void setUp() {
triangle=new Triangle(10,2,9);
}
public static Test suite() {
return new TestSuite(ExampleTest.class);
}
//函数isTriangle()的测试用例
public void testIsTriangle() {
assertTrue(triangle.isTriangle(triangle));
}
//函数isType()的测试用例
public void testIsType()
{
assertEquals("这次测试",triangle.isType(triangle),"不等边三角形");
}
//执行测试
public static void main (String[] args) {
//文本方式
junit.textui.TestRunner.run(suite());
//Swingui方式
//junit.swingui.TestRunner.run(suite().getClass());
//awtui方式
//junit.awtui.TestRunner.run(suite().getClass());
}
}
1、几个相关的概念
白盒测试——把测试对象看作一个打开的盒子，程序内部的逻辑结构和其他信息对测试人员是公开的。
回归测试——软件或环境的修复或更正后的“再测试”，自动测试工具对这类测试尤其有用。
单元测试——是最小粒度的测试，以测试某个功能或代码块。一般由程序员来做，因为它需要知道内部程序设计和编码的细节。
JUnit ——是一个开发源代码的Java测试框架，用于编写和运行可重复的测试。他是用于单元测试框架体系xUnit的一个实例（用于java语言）。主要用于白盒测试，回归测试。
2、单元测试概述
2.1、单元测试的好处
A、提高开发速度——测试是以自动化方式执行的，提升了测试代码的执行效率。
B、提高软件代码质量——它使用小版本发布至集成，便于实现人员除错。同时引入重构概念，让代码更干净和富有弹性。
C、提升系统的可信赖度——它是回归测试的一种。支持修复或更正后的“再测试”，可确保代码的正确性。
2．2、单元测试的针对对象
A、面向过程的软件开发针对过程。
B、面向对象的软件开发针对对象。
C、可以做类测试，功能测试，接口测试（最常用于测试类中的方法）。
2.3、单元测试工具和框架
目前的最流行的单元测试工具是xUnit系列框架，常用的根据语言不同分为JUnit（java），CppUnit（C++），DUnit （Delphi ），NUnit（.net），PhpUnit（Php ）等等。该测试框架的第一个和最杰出的应用就是由Erich Gamma （《设计模式》的作者）和Kent Beck（XP（Extreme Programming）的创始人 ）提供的开放源代码的JUnit。
3.Junit入门简介
3.1、JUnit的好处和JUnit单元测试编写原则
好处：
A、可以使测试代码与产品代码分开。
B、针对某一个类的测试代码通过较少的改动便可以应用于另一个类的测试。
C、易于集成到测试人员的构建过程中，JUnit和Ant的结合可以实施增量开发。
D、JUnit是公开源代码的，可以进行二次开发。
C、可以方便地对JUnit进行扩展。
编写原则：
A、是简化测试的编写，这种简化包括测试框架的学习和实际测试单元的编写。
B、是使测试单元保持持久性。
C、是可以利用既有的测试来编写相关的测试。
3.2、JUnit的特征
A、使用断言方法判断期望值和实际值差异，返回Boolean值。
B、测试驱动设备使用共同的初始化变量或者实例。
C、测试包结构便于组织和集成运行。
D、支持图型交互模式和文本交互模式。
3.3、JUnit框架组成
A、对测试目标进行测试的方法与过程集合，可称为测试用例(TestCase)。
B、测试用例的集合，可容纳多个测试用例(TestCase)，将其称作测试包(TestSuite)。
C、测试结果的描述与记录。(TestResult) 。
D、测试过程中的事件监听者(TestListener)。
E、每一个测试方法所发生的与预期不一致状况的描述，称其测试失败元素(TestFailure)
F、JUnit Framework中的出错异常（AssertionFailedError）。
JUnit框架是一个典型的Composite模式：TestSuite可以容纳任何派生自Test的对象；当调用TestSuite对象的run()方法是，会遍历自己容纳的对象，逐个调用它们的run()方法。（可参考《程序员》2003-6期）。
3.4、JUnit的安装和配置
JUnit安装步骤分解：
在http://download.sourceforge.net/junit/中下载JUnit包并将Junit压缩包解压到一个物理目录中（例如C：＼Junit3.8.1）。
记录Junit.jar文件所在目录名（例如C：＼Junit3.8.1\Junit.jar）。
进入操作系统（以Windows2000操作系统为准），按照次序点击“开始 设置 控制面板”。
在控制面板选项中选择“系统”，点击“环境变量”，在“系统变量”的“变量”列表框中选择“CLASS-PATH”关键字（不区分大小写），如果该关键字不存在则添加。
双击“CLASS-PATH”关键字添加字符串“C:＼Junit3.8.1\Junti.jar”(注意，如果已有别的字符串请在该字符串的字符结尾加上分号“；”)，这样确定修改后Junit就可以在集成环境中应用了。
对于IDE环境，对于需要用到的JUnit的项目增加到lib中，其设置不同的IDE有不同的设置 。
3.5、JUnit中常用的接口和类
Test接口——运行测试和收集测试结果
Test接口使用了Composite设计模式，是单独测试用例 （TestCase），聚合测试模式（TestSuite）及测试扩展（TestDecorator）的共同接口。
它的public int countTestCases（）方法，它来统计这次测试有多少个TestCase，另外一个方法就是public void run（ TestResult ），TestResult是实例接受测试结果， run方法执行本次测试。
TestCase抽象类——定义测试中固定方法
TestCase 是Test接口的抽象实现，（不能被实例化，只能被继承）其构造函数TestCase(string name)根据输入的测试名称name创建一个测试实例。由于每一个TestCase在创建时都要有一个名称，若某测试失败了，便可识别出是哪个测试失败。
TestCase类中包含的setUp()、tearDown()方法。setUp()方法集中初始化测试所需的所有变量和实例，并且在依次调用测试类中的每个测试方法之前再次执行setUp()方法。tearDown()方法则是在每个测试方法之后，释放测试程序方法中引用的变量和实例。
开发人员编写测试用例时，只需继承TestCase，来完成run方法即可，然后JUnit获得测试用例，执行它的run方法，把测试结果记录在TestResult之中。
Assert静态类——一系列断言方法的集合
Assert 包含了一组静态的测试方法，用于期望值和实际值比对是否正确，即测试失败，Assert类就会抛出一个AssertionFailedError异常，JUnit测试框架将这种错误归入Failes并加以记录，同时标志为未通过测试。如果该类方法中指定一个String类型的传参则该参数将被做为 AssertionFailedError异常的标识信息，告诉测试人员改异常的详细信息。
JUnit 提供了6大类31组断言方法，包括基础断言、数字断言、字符断言、布尔断言、对象断言。
其中assertEquals（Object expcted,Object actual)内部逻辑判断使用equals()方法，这表明断言两个实例的内部哈希值是否相等时，最好使用该方法对相应类实例的值进行比较。而 assertSame（Object expected,Object actual）内部逻辑判断使用了Java运算符“==”，这表明该断言判断两个实例是否来自于同一个引用（Reference），最好使用该方法对不同类的实例的值进行比对。asserEquals(String message,String expected,String actual)该方法对两个字符串进行逻辑比对，如果不匹配则显示着两个字符串有差异的地方。ComparisonFailure类提供两个字符串的比对，不匹配则给出详细的差异字符。
TestSuite测试包类——多个测试的组合
TestSuite类负责组装多个Test Cases。待测得类中可能包括了对被测类的多个测试，而TestSuit负责收集这些测试，使我们可以在一个测试中，完成全部的对被测类的多个测试。
TestSuite类实现了Test接口，且可以包含其它的TestSuites。它可以处理加入Test时的所有抛出的异常。
TestSuite处理测试用例有6个规约（否则会被拒绝执行测试）
A 测试用例必须是公有类（Public）
B 测试用例必须继承与TestCase类
C 测试用例的测试方法必须是公有的（ Public ）
D 测试用例的测试方法必须被声明为Void
E 测试用例中测试方法的前置名词必须是test
F 测试用例中测试方法误任何传递参数
n TestResult结果类和其它类与接口
TestResult结果类集合了任意测试累加结果，通过TestResult实例传递个每个测试的Run（）方法。TestResult在执行TestCase是如果失败会异常抛出
TestListener 接口是个事件监听规约，可供TestRunner类使用。它通知listener的对象相关事件，方法包括测试开始startTest(Test test)，测试结束endTest(Test test),错误，增加异常addError(Test test,Throwable t)和增加失败addFailure(Test test,AssertionFailedError t)
TestFailure失败类是个“失败”状况的收集类，解释每次测试执行过程中出现的异常情况。其toString()方法返回“失败”状况的简要描述
3.6、JUnit一个实例
在控制台中简单的范例如下：
1、写个待测试的Triangle类，创建一个TestCase的子类ExampleTest:
2、 ExampleTest中写一个或多个测试方法，断言期望的结果(注意：以test作为待测试的方法的开头，这样这些方法可以被自动找到并被测试)
3、 ExampleTest中写一个suite()方法，它会使用反射动态的创建一个包含所有的testXxxx方法的测试套件：
4、 ExampleTest可以写setUp()、tearDown()方法，以便于在测试时初始化或销毁测试所需的所有变量和实例。（不是必须的）
5、写一个main()方法以文本运行器或其它GUI的方式方便的运行测试
6、编译ExampleTest，执行测试。
3.7、Eclipse中JUnit的使用
Eclipse自带了一个JUnit的插件，不用安装就可以在你的项目中开始测试相关的类，并且可以调试你的测试用例和被测试类。
使用步骤如下：
1、新建一个测试用例，点击“File->New->Other…菜单项，在弹出的“New”对话框中选择”Java->JUnit”,下的TestCase 或TestSuite，就进入“New JUnit TestCase”对话框
2、在“New JUnit TestCase”对话框填写相应的栏目，主要有Name（测试用例名），SuperClass（测试的超类一般是默认的 junit.framework.TestCase），Class Under Test（被测试的类），Source Folder（测试用例保存的目录），Package（测试用例包名），及是否自动生成main,setUp,tearDown方法。
3、如果点击下面的”Next>”按钮，你还可以直接勾选你想测试的被测试类的方法，Eclipse将自动生成与被选方法相应的测试方法，点击“Fishish”按钮后一个测试用例就创建好了。
4、编写完成你的测试用例后，点击“Run”按钮就可以看到运行结果了。
3.8、JUnit的扩展应用
以下罗列了些JUnit的扩展应用：
JUnit + HttpUnit=WEB功能测试工具
JUnit + hansel =代码覆盖测试工具
JUnit + abbot =界面自动回放测试工具
JUnit + dbunit =数据库测试工具
JUnit + junitperf=性能测试工具
3.9、一些使用JUnit经验
不要用TestCase的构造函数初始化，而要用setUp()和tearDown()方法。
不要依赖或假定测试运行的顺序，因为JUnit利用Vector保存测试方法。所以不同的平台会按不同的顺序从Vector中取出测试方法。
避免编写有副作用的TestCase。例如：如果随后的测试依赖于某些特定的交易数据，就不要提交交易数据。简单的回滚就可以了。
当继承一个测试类时，记得调用父类的setUp()和tearDown()方法。
将测试代码和工作代码放在一起，一边同步编译和更新。
测试类和测试方法应该有一致的命名方案。如在工作类名前加上test从而形成测试类名。
确保测试与时间无关，不要依赖使用过期的数据进行测试。导致在随后的维护过程中很难重现测试。
如果你编写的软件面向国际市场，编写测试时要考虑国际化的因素。不要仅用母语的Locale进行测试。
尽可能地利用JUnit提供地assert/fail方法以及异常处理的方法，可以使代码更为简洁。
测试要尽可能地小，执行速度快。
参考资料与附件
1. http:// www.junit.org JUnit官方网站
2. http://bbs.51cmm.com 的测试论坛
3. http://www.uml.org.cn 的软件测试专栏
4. 单元测试 《程序员》 2002年7期
5. JUnit设计模式分析 《程序员》2003年6期
6. 《软件测试和JUnit实践》
7. 附件Triangle.java 一个要测试的类
8. 附件ExampleTest.java 一个测试用例类
Triangle.java
/**
* this is Triangle class
* @author liujun
*/
public class Triangle
{
//定义三角形的三边
protected long lborderA = 0;
protected long lborderB = 0;
protected long lborderC = 0;
//构造函数
public Triangle(long lborderA,long lborderB,long lborderC)
{
this.lborderA = lborderA;
this.lborderB = lborderB;
this.lborderC = lborderC;
}
/**
* 判断是否是三角形
* 是返回ture；不是返回false
*/
public boolean isTriangle(Triangle triangle)
{
boolean isTrue = false;
//判断边界，大于0小于200，出界返回false
if((triangle.lborderA>0&&triangle.lborderA<200)
&&(triangle.lborderB>0&&triangle.lborderB<200)
&&(triangle.lborderC>0&&triangle.lborderC<200))
{
//判断两边之和大于第三边
if((triangle.lborderA<(triangle.lborderB+triangle.lborderC))
&&(triangle.lborderB<(triangle.lborderA+triangle.lborderC))
&&(triangle.lborderC<(triangle.lborderA+triangle.lborderB)))
isTrue = true;
}
return isTrue;
}
/**
* 判断三角形类型
* 等腰三角形返回字符串“等腰三角形”；
* 等边三角形返回字符串“等边三角形”；
* 其它三角形返回字符串“不等边三角形”；
*/
public String isType(Triangle triangle)
{
String strType = "";
// 判断是否是三角形
if(this.isTriangle(triangle))
{
//判断是否是等边三角形 if(triangle.lborderA==triangle.lborderB&&triangle.lborderB==triangle.lborderC)
strType = "等边三角形";
//判断是否是不等边三角形
else if((triangle.lborderA!=triangle.lborderB)&&
(triangle.lborderB!=triangle.lborderC)&&
(triangle.lborderA!=triangle.lborderC))
strType = "不等边三角形";
else
strType="等腰三角形";
}
return strType;
}
}
ExampleTest.java
import junit.framework.*;
/**
* Some tests.
*
*/
public class ExampleTest extends TestCase {
public Triangle triangle;
//初始化
protected void setUp() {
triangle=new Triangle(10,2,9);
}
public static Test suite() {
return new TestSuite(ExampleTest.class);
}
//函数isTriangle()的测试用例
public void testIsTriangle() {
assertTrue(triangle.isTriangle(triangle));
}
//函数isType()的测试用例
public void testIsType()
{
assertEquals("这次测试",triangle.isType(triangle),"不等边三角形");
}
//执行测试
public static void main (String[] args) {
//文本方式
junit.textui.TestRunner.run(suite());
//Swingui方式
//junit.swingui.TestRunner.run(suite().getClass());
//awtui方式
//junit.awtui.TestRunner.run(suite().getClass());
}
}
Monday, April 27, 2009
linux下perforce(p4)的使用方法和命令
更多精彩请到 http://www.139ya.com
环境变量:
export P4PASSWD=abcdefg
export P4CLIENT=dyoldfish.com
export P4USER=dyoldfish
export P4PORT=192.168.1.198:1666
命令：
1、p4 client #配置本地信息
2、p4 sync #从perforce 下载文件
3、p4 login #登陆perforce
4、p4 help #显示关于命令的帮助
5、p4 -h #显示关于p4的帮助
6、 p4 labels ... #显示和这个目录相关的标签
7、p4 sync @dyoldfish_label #同步标签dyoldfish_label中的所有文件
8、p4 files @dyoldfish_label #查看标签dyoldfish_label所包含的文件列表
9、p4 revert #回复所有打开的文件
10、p4 revert -n ... #回复所有打开却没提交的文件
11、p4 branch dyoldfish_brach #新建分支
12、p4 integrate -b dyoldfish_brach #合并分支dyoldfish_brach中描述的文件
13、p4 opened #查看打开的文件
14、p4 help commands #查看p4所有命令的帮助
15、4 dirs -H . #显示当前目录
16、p4 branches #显示所有的分支
17、 p4 delete filename #从p4删除文件
18、p4 changelists -L ... #显示当前目录下面所有文件的修改注释
19、p4 label dyoldfish_label #新建标签 dyoldfish_label，编辑标签
20、p4 tag -l dyoldfish_label ... #把当前目录下面的所有文件添加到标签 dyoldfish_label
21、p4 changes ... #当前目录的changelist
22、 p4 sync @10931 #sync file @changelist
23、 p4 sync ...@10929 #only sync localfile@changelist
24、p4 help revisions #查看关于文件范围的帮助
环境变量:
export P4PASSWD=abcdefg
export P4CLIENT=dyoldfish.com
export P4USER=dyoldfish
export P4PORT=192.168.1.198:1666
命令：
1、p4 client #配置本地信息
2、p4 sync #从perforce 下载文件
3、p4 login #登陆perforce
4、p4 help #显示关于命令的帮助
5、p4 -h #显示关于p4的帮助
6、 p4 labels ... #显示和这个目录相关的标签
7、p4 sync @dyoldfish_label #同步标签dyoldfish_label中的所有文件
8、p4 files @dyoldfish_label #查看标签dyoldfish_label所包含的文件列表
9、p4 revert #回复所有打开的文件
10、p4 revert -n ... #回复所有打开却没提交的文件
11、p4 branch dyoldfish_brach #新建分支
12、p4 integrate -b dyoldfish_brach #合并分支dyoldfish_brach中描述的文件
13、p4 opened #查看打开的文件
14、p4 help commands #查看p4所有命令的帮助
15、4 dirs -H . #显示当前目录
16、p4 branches #显示所有的分支
17、 p4 delete filename #从p4删除文件
18、p4 changelists -L ... #显示当前目录下面所有文件的修改注释
19、p4 label dyoldfish_label #新建标签 dyoldfish_label，编辑标签
20、p4 tag -l dyoldfish_label ... #把当前目录下面的所有文件添加到标签 dyoldfish_label
21、p4 changes ... #当前目录的changelist
22、 p4 sync @10931 #sync file @changelist
23、 p4 sync ...@10929 #only sync localfile@changelist
24、p4 help revisions #查看关于文件范围的帮助
Saturday, April 25, 2009
扁豆闷面
更多精彩请到 http://www.139ya.com
周末闲来无事，决定实际操练一把刚从7日里学的扁豆闷面，说干就干:
鸡肉半斤，扁豆8两，切面1.2斤。
1. 把鸡肉切片，放在碗里用酱油腌着(电视里教的是用五花肉，因我不吃肥肉所以用鸡肉代替)
2. 把切面放在盆里，用少许食用油拌一下，尽量保证均匀(这是保证面条出锅后不粘不砣的关键)
3. 准备葱姜蒜，花椒，大料，扁豆切丝，准备一些蒜末，放在碗里用盐和香油腌着
4. 锅内放底油，开火，先下花椒，等出味后把花椒捞出，放入葱姜蒜，继续炒
5. 等出味后放第一步中腌制好的鸡肉，炒到鸡肉变色，下扁豆
6. 等扁豆炒熟后向锅内加水，以稍稍漫过扁豆为准
7. 等开锅后把锅内的水称出一半备用(这是关键点二，为的是保证面条不会因为接触水而失去口感)
8. 把第二步准备好的面条铺在扁豆上，盖上锅盖，小火焖10分钟(10分钟时电视上说的，我实际上焖了二十分钟，可能和火力的大小有关)
9. 闷的过程中每隔2分钟的把第7步称出的水沿着锅沿往锅中加一些(2分钟也是电视上说，我觉得具体的频率可以适度调整)
10. 焖好后关火，把第三步腌制的蒜末倒入锅中，拌匀。
11. 大功告成！
掀开锅盖那一瞬间，味道真是相当的抓人啊...，当然吃起来更是没的说，自此老张的私房菜即咖喱鸡，炸酱面后又隆重加入扁豆闷面！哈哈！
周末闲来无事，决定实际操练一把刚从7日里学的扁豆闷面，说干就干:
鸡肉半斤，扁豆8两，切面1.2斤。
1. 把鸡肉切片，放在碗里用酱油腌着(电视里教的是用五花肉，因我不吃肥肉所以用鸡肉代替)
2. 把切面放在盆里，用少许食用油拌一下，尽量保证均匀(这是保证面条出锅后不粘不砣的关键)
3. 准备葱姜蒜，花椒，大料，扁豆切丝，准备一些蒜末，放在碗里用盐和香油腌着
4. 锅内放底油，开火，先下花椒，等出味后把花椒捞出，放入葱姜蒜，继续炒
5. 等出味后放第一步中腌制好的鸡肉，炒到鸡肉变色，下扁豆
6. 等扁豆炒熟后向锅内加水，以稍稍漫过扁豆为准
7. 等开锅后把锅内的水称出一半备用(这是关键点二，为的是保证面条不会因为接触水而失去口感)
8. 把第二步准备好的面条铺在扁豆上，盖上锅盖，小火焖10分钟(10分钟时电视上说的，我实际上焖了二十分钟，可能和火力的大小有关)
9. 闷的过程中每隔2分钟的把第7步称出的水沿着锅沿往锅中加一些(2分钟也是电视上说，我觉得具体的频率可以适度调整)
10. 焖好后关火，把第三步腌制的蒜末倒入锅中，拌匀。
11. 大功告成！
掀开锅盖那一瞬间，味道真是相当的抓人啊...，当然吃起来更是没的说，自此老张的私房菜即咖喱鸡，炸酱面后又隆重加入扁豆闷面！哈哈！
Thursday, April 23, 2009
JBoss端口
更多精彩请到 http://www.139ya.com
Jboss通常占用的端口是1098，1099，4444，4445，8080，8009，8083，8093这几个，
默认端口是8080
在windows系统中：
1098、1099、4444、4445、8083端口在\jboss\server\default\conf\jboss-service.xml中
8080端口在\jboss\server\default\deploy\jboss-web.deployer\server.xml中
8093端口在\jboss\server\default\deploy\jms\uil2-service.xml中。
Jboss通常占用的端口是1098，1099，4444，4445，8080，8009，8083，8093这几个，
默认端口是8080
在windows系统中：
1098、1099、4444、4445、8083端口在\jboss\server\default\conf\jboss-service.xml中
8080端口在\jboss\server\default\deploy\jboss-web.deployer\server.xml中
8093端口在\jboss\server\default\deploy\jms\uil2-service.xml中。
WebService 概念
更多精彩请到 http://www.139ya.com
转自： http://blog.csdn.net/zhangjian01361/archive/2006/08/24/1113779.aspx
1.定义
由两部分组成
·SOAP--Web Service之间的基本通信协议。
·WSDL--Web Service描述语言，它定义了Web Service做什么，怎么做和查询的信息。
2.简单的Web Service实现
包含四个基本步骤
·创建Web Service的商业逻辑（通常是一些Java类）
·将这些Java类部署到一个SOAP服务器上
·生成客户访问代码
·部署客户应用
注意：WSDL等文件的生成通常是利用厂商提供的工具来完成
3.SOAP
Soap 是 XML Web Service 的通信协议。当把 SOAP 描述为一种通信协议时，多数人都会想到 DCOM 或 CORBA，并且会问“SOAP 如何激活对象？”或“SOAP 使用什么样的命名服务？”等问题。虽然 SOAP 实现方案可能会包含上述内容，但 SOAP 标准并未对其进行规定。SOAP 一种规范，用来定义消息的 XML 格式 - 这是规范中所必需的部分。包含在一对 SOAP 元素中的、结构正确的 XML 段就是 SOAP 消息。这是不是很简单？
SOAP 规范的其他部分介绍如何将程序数据表示为 XML，以及如何使用 SOAP 进行远程过程调用 (RPC)。这些可选的规范部分用于实现 RPC 形式的应用程序，其中客户端将发出一条 SOAP 消息（包含可调用函数，以及要传送到该函数的参数），然后服务器将返回包含函数执行结果的消息。目前，多数 SOAP 实现方案都支持 RPC 应用程序，这是因为习惯于开发 COM 或 CORBA 应用程序的编程人员熟悉 RPC 形式。SOAP 还支持文档形式的应用程序，在这类应用程序中，SOAP 消息只是 XML 文档的一个包装。文档形式的 SOAP 应用程序非常灵活，许多新的 XML Web Service 都利用这一特点来构建使用 RPC 难以实现的服务。
SOAP 规范的最后一个可选部分定义了包含 SOAP 消息的 HTTP 消息的样式。此 HTTP 绑定非常重要，因为几乎所有当前的 OS（以及许多以前的 OS）都支持 HTTP。HTTP 绑定虽然是可选的，但几乎所有 SOAP 实现方案都支持 HTTP 绑定，因为它是 SOAP 的唯一标准协议。由于这一原因，人们通常误认为 SOAP 必须使用 HTTP。其实，有些实现方案也支持 MSMQ、MQ 系列、SMTP 或 TCP/IP 传输，但由于 HTTP 非常普遍，几乎所有当前的 XML Web Service 都使用它。由于 HTTP 是 Web 的核心协议，因此大多数组织的网络基础结构都支持 HTTP，并且员工已经了解了如何对其进行管理。如今，已经建立了用于 HTTP 的安全保护、监视和负载平衡的基础结构。
4.WSDL解析
WSDL描述语言一般包含三部分
·What部分--包括了type、message和portType元素
Type：定义了Web Service使用的数据结构（使用XML Schema定义）
Message：一个Message是SOAP的基本通信元素。每个Message可以有一个或多个Part，每个Part代表一个参数。
PortType：消息汇总为不同的操作并归入到一个被称为portType的实体中。一个portType代表一个接口（Web Service支 持的操作集合），每个Web Service可以有多个接口，它们都使用portType表示。每个操作又包含了input和 output部分。
·How部分--包含binding元素
binding元素将portType绑定到特定的通信协议上（如HTTP上的SOAP协议）
·Where部分--由service元素组成
它将portType,binding以及Web Service实际的位置（URI）放在一起描述
5.客户端
通常Web Service可以有三种类型的客户
·商业伙伴（Business Partner）--包括分发商，零售商以及大型消费者）
此类客户通过SOAP、WSDL、ebXML、UDDI等XML技术与Web Service连接
·瘦客户--包括Web浏览器、PDA以及无线设备
该类客户通常经由轻量协议(如HTTP)与Web Service连接
·肥客户--包括Applet、各类应用以及现存系统
通常使用重量级协议（如IIOP）连接Web Service
转自： http://blog.csdn.net/zhangjian01361/archive/2006/08/24/1113779.aspx
1.定义
由两部分组成
·SOAP--Web Service之间的基本通信协议。
·WSDL--Web Service描述语言，它定义了Web Service做什么，怎么做和查询的信息。
2.简单的Web Service实现
包含四个基本步骤
·创建Web Service的商业逻辑（通常是一些Java类）
·将这些Java类部署到一个SOAP服务器上
·生成客户访问代码
·部署客户应用
注意：WSDL等文件的生成通常是利用厂商提供的工具来完成
3.SOAP
Soap 是 XML Web Service 的通信协议。当把 SOAP 描述为一种通信协议时，多数人都会想到 DCOM 或 CORBA，并且会问“SOAP 如何激活对象？”或“SOAP 使用什么样的命名服务？”等问题。虽然 SOAP 实现方案可能会包含上述内容，但 SOAP 标准并未对其进行规定。SOAP 一种规范，用来定义消息的 XML 格式 - 这是规范中所必需的部分。包含在一对 SOAP 元素中的、结构正确的 XML 段就是 SOAP 消息。这是不是很简单？
SOAP 规范的其他部分介绍如何将程序数据表示为 XML，以及如何使用 SOAP 进行远程过程调用 (RPC)。这些可选的规范部分用于实现 RPC 形式的应用程序，其中客户端将发出一条 SOAP 消息（包含可调用函数，以及要传送到该函数的参数），然后服务器将返回包含函数执行结果的消息。目前，多数 SOAP 实现方案都支持 RPC 应用程序，这是因为习惯于开发 COM 或 CORBA 应用程序的编程人员熟悉 RPC 形式。SOAP 还支持文档形式的应用程序，在这类应用程序中，SOAP 消息只是 XML 文档的一个包装。文档形式的 SOAP 应用程序非常灵活，许多新的 XML Web Service 都利用这一特点来构建使用 RPC 难以实现的服务。
SOAP 规范的最后一个可选部分定义了包含 SOAP 消息的 HTTP 消息的样式。此 HTTP 绑定非常重要，因为几乎所有当前的 OS（以及许多以前的 OS）都支持 HTTP。HTTP 绑定虽然是可选的，但几乎所有 SOAP 实现方案都支持 HTTP 绑定，因为它是 SOAP 的唯一标准协议。由于这一原因，人们通常误认为 SOAP 必须使用 HTTP。其实，有些实现方案也支持 MSMQ、MQ 系列、SMTP 或 TCP/IP 传输，但由于 HTTP 非常普遍，几乎所有当前的 XML Web Service 都使用它。由于 HTTP 是 Web 的核心协议，因此大多数组织的网络基础结构都支持 HTTP，并且员工已经了解了如何对其进行管理。如今，已经建立了用于 HTTP 的安全保护、监视和负载平衡的基础结构。
4.WSDL解析
WSDL描述语言一般包含三部分
·What部分--包括了type、message和portType元素
Type：定义了Web Service使用的数据结构（使用XML Schema定义）
Message：一个Message是SOAP的基本通信元素。每个Message可以有一个或多个Part，每个Part代表一个参数。
PortType：消息汇总为不同的操作并归入到一个被称为portType的实体中。一个portType代表一个接口（Web Service支 持的操作集合），每个Web Service可以有多个接口，它们都使用portType表示。每个操作又包含了input和 output部分。
·How部分--包含binding元素
binding元素将portType绑定到特定的通信协议上（如HTTP上的SOAP协议）
·Where部分--由service元素组成
它将portType,binding以及Web Service实际的位置（URI）放在一起描述
5.客户端
通常Web Service可以有三种类型的客户
·商业伙伴（Business Partner）--包括分发商，零售商以及大型消费者）
此类客户通过SOAP、WSDL、ebXML、UDDI等XML技术与Web Service连接
·瘦客户--包括Web浏览器、PDA以及无线设备
该类客户通常经由轻量协议(如HTTP)与Web Service连接
·肥客户--包括Applet、各类应用以及现存系统
通常使用重量级协议（如IIOP）连接Web Service
Wednesday, April 22, 2009
httpurlconnection 超时设置 (jdk1.4)
更多精彩请到 http://www.139ya.com
import java.util.*;
import java.net.*;
import java.io.*;
public class TimedUrlConnection implements Observer {
private URLConnection ucon = null;
private int time = 300000;//max time out
private boolean connected = false;
public TimedUrlConnection (URLConnection ucon,int time) {
this.ucon = ucon;
this.time = time;
}
public boolean connect() {
ObservableURLConnection ouc = new
ObservableURLConnection(ucon);
ouc.addObserver(this);
Thread ouct = new Thread(ouc);
ouct.start();
try {
ouct.join(time);
}
catch (InterruptedException i) {
//false, but should already be false
}
return(connected);
}
public void update(Observable o, Object arg) {
connected = true;
}//end of public void update(Observable o, Object arg)
}
class ObservableURLConnection extends Observable implements Runnable {
private URLConnection ucon;
public ObservableURLConnection(URLConnection ucon) {
this.ucon = ucon;
}//end of constructor
public void run() {
try {
ucon.connect();
setChanged();
notifyObservers();
}
catch (IOException e) {
}
}//end of public void run()
}
//~~~~~~~~~~~~~~~~~~~Usage~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
URL url=new URL(someurlname);
URLConnection urlconn=url.openConnection();
TimedUrlConnection timeoutconn=new TimedUrlConnection(urlconn,100000);//time out: 100seconds
boolean bconnectok=timeoutconn.connect();
if(bconnectok==false)
{
//urlconn fails to connect in 100seconds
}
else
{
//connect ok
}
http://topic.csdn.net/t/20010823/09/252141.html
（二）
HttpURLConnection中如何设置网络超时
2005年02月03日 益众网
作者：happy_fish
Java中可以使用HttpURLConnection来请求WEB资源。
HttpURLConnection对象不能直接构造，需要通过URL.openConnection()来获得HttpURLConnection对象，示例代码如下：
String szUrl = "http://www.ee2ee.com/";
URL url = new URL(szUrl);
HttpURLConnection urlCon = (HttpURLConnection)url.openConnection();
HttpURLConnection是基于HTTP协议的，其底层通过socket通信实现。如果不设置超时（timeout），在网络异常的情况下，可能会导致程序僵死而不继续往下执行。可以通过以下两个语句来设置相应的超时：
System.setProperty("sun.net.client.defaultConnectTimeout", 超时毫秒数字符串);
System.setProperty("sun.net.client.defaultReadTimeout", 超时毫秒数字符串);
其中： sun.net.client.defaultConnectTimeout：连接主机的超时时间（单位：毫秒）
sun.net.client.defaultReadTimeout：从主机读取数据的超时时间（单位：毫秒）
例如：
System.setProperty("sun.net.client.defaultConnectTimeout", "30000");
System.setProperty("sun.net.client.defaultReadTimeout", "30000");
JDK 1.5以前的版本，只能通过设置这两个系统属性来控制网络超时。在1.5中，还可以使用HttpURLConnection的父类URLConnection的以下两个方法：
setConnectTimeout：设置连接主机超时（单位：毫秒）
setReadTimeout：设置从主机读取数据超时（单位：毫秒）
例如：
HttpURLConnection urlCon = (HttpURLConnection)url.openConnection();
urlCon.setConnectTimeout(30000);
urlCon.setReadTimeout(30000);
需要注意的是，笔者在JDK1.4.2环境下，发现在设置了defaultReadTimeout的情况下，如果发生网络超时，HttpURLConnection会自动重新提交一次请求，出现一次请求调用，请求服务器两次的问题（Trouble）。
import java.util.*;
import java.net.*;
import java.io.*;
public class TimedUrlConnection implements Observer {
private URLConnection ucon = null;
private int time = 300000;//max time out
private boolean connected = false;
public TimedUrlConnection (URLConnection ucon,int time) {
this.ucon = ucon;
this.time = time;
}
public boolean connect() {
ObservableURLConnection ouc = new
ObservableURLConnection(ucon);
ouc.addObserver(this);
Thread ouct = new Thread(ouc);
ouct.start();
try {
ouct.join(time);
}
catch (InterruptedException i) {
//false, but should already be false
}
return(connected);
}
public void update(Observable o, Object arg) {
connected = true;
}//end of public void update(Observable o, Object arg)
}
class ObservableURLConnection extends Observable implements Runnable {
private URLConnection ucon;
public ObservableURLConnection(URLConnection ucon) {
this.ucon = ucon;
}//end of constructor
public void run() {
try {
ucon.connect();
setChanged();
notifyObservers();
}
catch (IOException e) {
}
}//end of public void run()
}
//~~~~~~~~~~~~~~~~~~~Usage~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
URL url=new URL(someurlname);
URLConnection urlconn=url.openConnection();
TimedUrlConnection timeoutconn=new TimedUrlConnection(urlconn,100000);//time out: 100seconds
boolean bconnectok=timeoutconn.connect();
if(bconnectok==false)
{
//urlconn fails to connect in 100seconds
}
else
{
//connect ok
}
http://topic.csdn.net/t/20010823/09/252141.html
（二）
HttpURLConnection中如何设置网络超时
2005年02月03日 益众网
作者：happy_fish
Java中可以使用HttpURLConnection来请求WEB资源。
HttpURLConnection对象不能直接构造，需要通过URL.openConnection()来获得HttpURLConnection对象，示例代码如下：
String szUrl = "http://www.ee2ee.com/";
URL url = new URL(szUrl);
HttpURLConnection urlCon = (HttpURLConnection)url.openConnection();
HttpURLConnection是基于HTTP协议的，其底层通过socket通信实现。如果不设置超时（timeout），在网络异常的情况下，可能会导致程序僵死而不继续往下执行。可以通过以下两个语句来设置相应的超时：
System.setProperty("sun.net.client.defaultConnectTimeout", 超时毫秒数字符串);
System.setProperty("sun.net.client.defaultReadTimeout", 超时毫秒数字符串);
其中： sun.net.client.defaultConnectTimeout：连接主机的超时时间（单位：毫秒）
sun.net.client.defaultReadTimeout：从主机读取数据的超时时间（单位：毫秒）
例如：
System.setProperty("sun.net.client.defaultConnectTimeout", "30000");
System.setProperty("sun.net.client.defaultReadTimeout", "30000");
JDK 1.5以前的版本，只能通过设置这两个系统属性来控制网络超时。在1.5中，还可以使用HttpURLConnection的父类URLConnection的以下两个方法：
setConnectTimeout：设置连接主机超时（单位：毫秒）
setReadTimeout：设置从主机读取数据超时（单位：毫秒）
例如：
HttpURLConnection urlCon = (HttpURLConnection)url.openConnection();
urlCon.setConnectTimeout(30000);
urlCon.setReadTimeout(30000);
需要注意的是，笔者在JDK1.4.2环境下，发现在设置了defaultReadTimeout的情况下，如果发生网络超时，HttpURLConnection会自动重新提交一次请求，出现一次请求调用，请求服务器两次的问题（Trouble）。
【Java】java.net.HttpURLConnection的使用
更多精彩请到 http://www.139ya.com
1.网页内容获取
java.io.inputstream in;
java.net.url url = new java.net.url(www.xyz.com/content.html);
java.net.httpurlconnection connection = (java.net.httpurlconnection)
url.openconnection();
connection = (java.net.httpurlconnection) url.openconnection();
//模拟成ie
connection.setrequestproperty("user-agent","mozilla/4.0 (compatible; msie 6.0; windows 2000)");
connection.connect();
in = connection.getinputstream();
java.io.bufferedreader breader =
new bufferedreader(new inputstreamreader(in , "gbk"));
string str=breader.readline());
while(st != null){
system.out.println(str);
str=breader.readline());
}
2.cookie管理
1.直接的方式
取得cookie：
httpurlconnection huc= (httpurlconnection) url.openconnection();
inputstream is = huc.getinputstream();
// 取得sessionid.
string cookieval = hc.getheaderfield("set-cookie");
string sessionid;
if(cookieval != null)
{
sessionid = cookieval.substring(0, cookieval.indexof(";"));
}
发送设置cookie：
httpurlconnection huc= (httpurlconnection) url.openconnection();
if(sessionid != null)
{
huc.setrequestproperty("cookie", sessionid);
}
inputstream is = huc.getinputstream();
2.利用的jcookie包(http://jcookie.sourceforge.net/ )
获取cookie:
url url = new url("http://www.site.com/");
httpurlconnection huc = (httpurlconnection) url.openconnection();
huc.connect();
inputstream is = huc.getinputstream();
client client = new client();
cookiejar cj = client.getcookies(huc);
新的请求,利用上面获取的cookie:
url = new url("http://www.site.com/");
huc = (httpurlconnection) url.openconnection();
client.setcookies(huc, cj);
3.post方式的模拟
url url = new url("www.xyz.com");
httpurlconnection huc = (httpurlconnection) url.openconnection();
//设置允许output
huc.setdooutput(true);
//设置为post方式
huc.setrequestmethod("post");
huc.setrequestproperty("user-agent","mozilla/4.7 [en] (win98; i)");
stringbuffer sb = new stringbuffer();
sb.append("username="+usernme);
sb.append("&password="+password);
//post信息
outputstream os = huc.getoutputstream();
os.write(sb.tostring().getbytes("gbk"));
os.close();
bufferedreader br = new bufferedreader(new inputstreamreader(huc.getinputstream()))
huc.connect();
string line = br.readline();
while(line != null){
l
system.out.printli(line);
line = br.readline();
}
1.网页内容获取
java.io.inputstream in;
java.net.url url = new java.net.url(www.xyz.com/content.html);
java.net.httpurlconnection connection = (java.net.httpurlconnection)
url.openconnection();
connection = (java.net.httpurlconnection) url.openconnection();
//模拟成ie
connection.setrequestproperty("user-agent","mozilla/4.0 (compatible; msie 6.0; windows 2000)");
connection.connect();
in = connection.getinputstream();
java.io.bufferedreader breader =
new bufferedreader(new inputstreamreader(in , "gbk"));
string str=breader.readline());
while(st != null){
system.out.println(str);
str=breader.readline());
}
2.cookie管理
1.直接的方式
取得cookie：
httpurlconnection huc= (httpurlconnection) url.openconnection();
inputstream is = huc.getinputstream();
// 取得sessionid.
string cookieval = hc.getheaderfield("set-cookie");
string sessionid;
if(cookieval != null)
{
sessionid = cookieval.substring(0, cookieval.indexof(";"));
}
发送设置cookie：
httpurlconnection huc= (httpurlconnection) url.openconnection();
if(sessionid != null)
{
huc.setrequestproperty("cookie", sessionid);
}
inputstream is = huc.getinputstream();
2.利用的jcookie包(http://jcookie.sourceforge.net/ )
获取cookie:
url url = new url("http://www.site.com/");
httpurlconnection huc = (httpurlconnection) url.openconnection();
huc.connect();
inputstream is = huc.getinputstream();
client client = new client();
cookiejar cj = client.getcookies(huc);
新的请求,利用上面获取的cookie:
url = new url("http://www.site.com/");
huc = (httpurlconnection) url.openconnection();
client.setcookies(huc, cj);
3.post方式的模拟
url url = new url("www.xyz.com");
httpurlconnection huc = (httpurlconnection) url.openconnection();
//设置允许output
huc.setdooutput(true);
//设置为post方式
huc.setrequestmethod("post");
huc.setrequestproperty("user-agent","mozilla/4.7 [en] (win98; i)");
stringbuffer sb = new stringbuffer();
sb.append("username="+usernme);
sb.append("&password="+password);
//post信息
outputstream os = huc.getoutputstream();
os.write(sb.tostring().getbytes("gbk"));
os.close();
bufferedreader br = new bufferedreader(new inputstreamreader(huc.getinputstream()))
huc.connect();
string line = br.readline();
while(line != null){
l
system.out.printli(line);
line = br.readline();
}
[JAVA]使用HttpURLConnection进行POST方式提交
更多精彩请到 http://www.139ya.com
转自: http://www.blogjava.net/sunfruit/archive/2006/03/13/35048.html
[JAVA]使用HttpURLConnection进行POST方式提交
--sunfruit
用HttpURLConnection进行Post方式提交，下面给出一个例子
URL url = null;
HttpURLConnection httpurlconnection = null;
try
{
url = new URL("http://xxxx");
httpurlconnection = (HttpURLConnection) url.openConnection();
httpurlconnection.setDoOutput(true);
httpurlconnection.setRequestMethod("POST");
String username="username=02000001";
httpurlconnection.getOutputStream().write(username.getBytes());
httpurlconnection.getOutputStream().flush();
httpurlconnection.getOutputStream().close();
int code = httpurlconnection.getResponseCode();
System.out.println("code " + code);
}
catch(Exception e)
{
e.printStackTrace();
}
finally
{
if(httpurlconnection!=null)
httpurlconnection.disconnect();
}
其中HttpURLConnection中的addRequestProperty方法，并不是用来添加Parameter 的，而是用来设置请求的头信息，比如：
setRequestProperty("Content-type","text/html");
setRequestProperty("Connection", "close");
setRequestProperty("Content-Length",xxx);
当然如果不设置的话，可以走默认值，上面的例子中就没有进行相关设置，但是也可以正确执行
转自: http://www.blogjava.net/sunfruit/archive/2006/03/13/35048.html
[JAVA]使用HttpURLConnection进行POST方式提交
--sunfruit
用HttpURLConnection进行Post方式提交，下面给出一个例子
URL url = null;
HttpURLConnection httpurlconnection = null;
try
{
url = new URL("http://xxxx");
httpurlconnection = (HttpURLConnection) url.openConnection();
httpurlconnection.setDoOutput(true);
httpurlconnection.setRequestMethod("POST");
String username="username=02000001";
httpurlconnection.getOutputStream().write(username.getBytes());
httpurlconnection.getOutputStream().flush();
httpurlconnection.getOutputStream().close();
int code = httpurlconnection.getResponseCode();
System.out.println("code " + code);
}
catch(Exception e)
{
e.printStackTrace();
}
finally
{
if(httpurlconnection!=null)
httpurlconnection.disconnect();
}
其中HttpURLConnection中的addRequestProperty方法，并不是用来添加Parameter 的，而是用来设置请求的头信息，比如：
setRequestProperty("Content-type","text/html");
setRequestProperty("Connection", "close");
setRequestProperty("Content-Length",xxx);
当然如果不设置的话，可以走默认值，上面的例子中就没有进行相关设置，但是也可以正确执行
利用java的HttpURLConnection和Servlet通信,Post方式
更多精彩请到 http://www.139ya.com
利用java的HttpURLConnection和Servlet通信,Post方式
利用java的HttpURLConnection和Servlet通信,Post方式
import java.net.*;
import java.io.*;
public class testPost {
public static void main() {
URL url = null;
HttpURLConnection conn = null;
try {
url = new URL("http://localhost/projectname/servletname"); //构造好这个URL对象，参数就是你要通信的servlet地址，实际测试的时候，这个URL可以从Properties文件中取得，以增加灵活性
conn = (HttpURLConnection)url.openConnection(); //打开，创建Connection对象
conn.setRequestMethod("POST"); //设定请求方式为POST
conn.setDoOutput(true); //一定要设为true,因为要发送数据
//下面开始设定Http头
conn.setRequestProperty("Content-Type","multipart/form-data; boundary=Bounday---");
conn.setRequestProperty("Cache-Control","no-cache");
.......
// 传送送据
OutputStream buf = conn.getOutoutStream();
buf = new BufferedOutputStream(buf);
OutputStreamWriter out = new OutputStreamWriter (buf);
out.write("这里是要传送的数据")；
//比方说如下的格式,当然这是自己规定的格式，这些都可以从配置文件中设定，然后读取
//Bounday---
//Content-Disposition: form-data; name="testRequestHeader"
// Data = aabbccddeeffgghh
//--Bounday---
out.flush(); //这个一定要
out.clost();
//接收数据
InputStream in = conn.getInputStream();
in = new BufferedOutputStream(buf);
Reader rData = new InputStreamReader(in);
int c;
System.out.println("=====================Result==========================");
while((c=rData.read()) != -1)
System.out.print((char)c);
System.out.println("===================================================");
in.close();
} catch (Exception e) {
e.printStackTrace();
} finally {
}
}
}
java httpurlconnection 登录网站 完整代码
更多精彩请到 http://www.139ya.com
1. import java.io.*;
2. import java.util.*;
3. import java.net.*;
4.
5. public class WebTest {
6.
7. public static void main(String[] args) {
8.
9. System.out.println("beging...");
10. DownLoadPages("http://login.xiaonei.com/Login.do", "d:/fileDown.txt");
11. // visit("http://www.xiaonei.com");
12. System.out.println("end.");
13. }
14.
15. public static void DownLoadPages(String urlStr, String outPath) {
16. int chByte = 0;
17.
18. URL url = null;
19.
20. HttpURLConnection httpConn = null;
21.
22. InputStream in = null;
23.
24. FileOutputStream out = null;
25.
26. try {
27. String post = "email=" + URLEncoder.encode("e-mail", "UTF-8")
28. + "&password=" + "password";
29. url = new URL(urlStr);
30.
31. httpConn = (HttpURLConnection) url.openConnection();
32.
33. //setInstanceFollowRedirects can then be used to set if
34. //redirects should be followed or not and this should be used before the
35. //connection is established (via getInputStream, getResponseCode, and other
36. //methods that result in the connection being established).
37.
38. httpConn.setFollowRedirects(false);
39.
40. //inorder to disable the redirects
41. httpConn.setInstanceFollowRedirects(false);
42.
43. httpConn.setDoOutput(true);
44. httpConn.setDoInput(true);
45. httpConn.setRequestProperty("User-Agent",
46. "Mozilla/5.0 (compatible; MSIE 6.0; Windows NT)");
47. httpConn.setRequestProperty("Content-Type",
48. "application/x-www-form-urlencoded");
49.
50. //ok now, we can post it
51. PrintStream send = new PrintStream(httpConn.getOutputStream());
52. send.print(post);
53. send.close();
54. URL newURL = new URL(httpConn.getHeaderField("Location"));
55. System.out.println("the URL has move to "
56. + httpConn.getHeaderField("Location"));
57. httpConn.disconnect();
58.
59. // OK, now we are ready to get the cookies out of the URLConnection
60. String cookies = getCookies(httpConn);
61. System.out.println(cookies);
62. httpConn = (HttpURLConnection) newURL.openConnection();
63. httpConn.setRequestProperty("User-Agent",
64. "Mozilla/5.0 (compatible; MSIE 6.0; Windows NT)");
65. httpConn.setRequestProperty("Content-Type",
66. "application/x-www-form-urlencoded");
67. httpConn.setRequestProperty("Cookie", cookies);
68.
69. httpConn.setDoInput(true);
70. in = httpConn.getInputStream();
71. out = new FileOutputStream(new File(outPath));
72.
73. chByte = in.read();
74. while (chByte != -1) {
75. out.write(chByte);
76. //System.out.println(chByte);
77. chByte = in.read();
78. }
79. } catch (Exception e) {
80. e.printStackTrace();
81. }
82. }
83.
84. public static String getCookies(HttpURLConnection conn) {
85. StringBuffer cookies = new StringBuffer();
86. String headName;
87. for (int i = 7; (headName = conn.getHeaderField(i)) != null; i++) {
88. StringTokenizer st = new StringTokenizer(headName, "; ");
89. while (st.hasMoreTokens()) {
90. cookies.append(st.nextToken() + "; ");
91. }
92. }
93. return cookies.toString();
94. }
95. }
Tuesday, April 21, 2009
设置一个基本的OpenLDAP Server
更多精彩请到 http://www.139ya.com
Berkeley DB : http://www.oracle.com/technology/products/berkeley-db/db/index.html
下载BerkeleyDB
[root@rhas4min79 openldap-2.4.16]# tar zxvf openldap-db-4.7.25.tar.gz
[root@rhas4min79 openldap-2.4.16]# cd soft/db-4.7.25/build_unix/
[root@rhas4min79 openldap-2.4.16]# ../dist/configure --prefix=/usr/local/BerkeleyDB/
#make
#make install
BerkeleyDB安装结束，开始安装OPENLDAP，下载openldap
设置环境变量
export CPPFLAGS="-I/usr/local/BerkeleyDB/include"
export LDFLAGS="-L/usr/local/lib -L/usr/local/BerkeleyDB/lib -R/usr/local/BerkeleyDB/lib"
export LD_LIBRARY_PATH="/usr/local/BerkeleyDB/lib"
# tar zxvf openldap-2.4.16.tgz
# cd openldap-2.4.16
# ./configure --prefix=/usr/local/openldap
# make depend
# make
# make test
# make install
设置一个基本的OpenLDAP Server
一. 目的
本文旨在介绍如何安装OpenLDAP并且设置一个公司内部的集中化的邮件地址薄服务器供客户端查询。
基本上，OpenLDAPg还应用在其它许多方面，象集中化的用户帐号验证服务器，但邮件地址薄查询是最常用的。
二. 安装
从www.openldap.org下载最新的openldap软件包，按照编译和安装的步骤，依次运行：
#tar cvfz openldap-stable-20010524.tgz
#cd openldap-2.0.11
#./configure
#make depend
#make
#make test
#make install
我的操作环境是redhat 6.1，如果没有遇到任何错误，最后默认安装LDAP后台程序slapd到目录/usr/local/libexec；配置文件在目录/usr/local/etc/openldap/ 并且放各种OpenLDAP工具
ldapadd,ldapdelete,ldapmodify,ldapmodrdn,ldappasswd,ldapsearch在目录/usr/local/bin，运行时数据库在/usr/local/var/openldap-ldbm。
三. 设置
1) 更改配置文件/usr/local/etc/openldap/slapd.conf
在include /usr/local/etc/openldap/schema/core.schema这行后面加上下面的行，包括所有的方案。
include /usr/local/etc/openldap/schema/corba.schema
include /usr/local/etc/openldap/schema/cosine.schema
include /usr/local/etc/openldap/schema/inetorgperson.schema
include /usr/local/etc/openldap/schema/java.schema
include /usr/local/etc/openldap/schema/krb5-kdc.schema
include /usr/local/etc/openldap/schema/misc.schema
include /usr/local/etc/openldap/schema/nadf.schema
include /usr/local/etc/openldap/schema/nis.schema
include /usr/local/etc/openldap/schema/openldap.schema
2) 在文件slapd.conf的"ldbm database definitions"部分更改相应的suffix,rootdn行如下
database ldbm
suffix "o=yourdomain,c=us"
rootdn "cn=root,o=yourdomain,c=us"
rootpw secret
directory /usr/local/var/openldap-ldbm
有各种格式你可以用，这里我用的是o=yourdomain,c=us 说明你的公司域名和所在的国家或地区。
rootdn的格式安装后默认为cn=Manager,这里改为root完全是自己的喜好,这样符合Unix/Linux中root具有最高权限的传统。
3) 现在可以启动slapd了，运行/usr/local/libexec/slapd 。
可以考虑把/usr/local/bin and /usr/local/libexec加到搜索路径中，即加到/etc/profile
中的PATH行:
PATH="$PATH:/usr/X11R6/bin:/usr/local/bin:/usr/local/libexec"
这样下次登录后只需键入 slapd 。
4) 测试ldap server是否正常工作。
运行下面的命令检查是否有相应的输出。
#ldapsearch -x -b 'o=yourdomain,c=us' '(objectclass=*)'
陈绪先生注：有误，应该为
ldapsearch -x -b '' -s base '(objectclass=*)' namingContexts
或者
ldapsearch -x -b '' -s base '(objectclass=*)'
5) 编辑.ldif文本文件，用ldapadd添加记录进入LDAP数据库。
文件内容如下：
dn: o=yourdomain,c=us
objectclass: dcobject
objectclass: organization
o: yourdomain
dc: yourdomain
dn: cn=Jephe Wu,o=yourdomain,c=us
objectclass: inetorgperson
cn: Jephe Wu
sn: Wu
mail: jephe_wu@yourdomain.com
......more users......
依次类推，添加每个人的记录进入该文件中，注意对象类型 inetorgperson 至少必须要有cn和sn，这里我们用cn,sn,mail三项定义,这对我们的邮件地址薄功能来说已经足够。你还可以定义象mobile, homephone,pager......等等。
然后用下面的命令添加上面的.ldif文件进入LDAP数据库
#ldapadd -x -D "cn=root,o=yourdomain,c=us" -w secret -f "yourldiffilename"
注：上面的文件的第一部分"dn: o=yourdomain,c=us"是必须的，否则不能添加数据。
用你的公司的域名替换上面的"yourdomain"。
6) 设置Outlook Express, 允许用LDAP服务器查询邮件地址。
"工具/帐号/添加--目录服务"，填入你的服务器的IP地址或者主机全称域名，在下一个屏幕中选yes以允许用目录服务来查询地址，最后在"目录服务"栏中选中刚才设置的项目击“属性/高级",在"搜索库"中填入"o=yourdomain,c=us"。
Netscape请根据上面的信息设置相应的选项。
四. 常见使用问题
1) 能启动slapd 没有问题，但不能添加数据库，运行ldapadd添加时出错 "ldap_bind:cannot contact LDAP Server" 。
答: 最可能的原因是在/etc/hosts中没有127.0.0.1 localhost项目。
2) 注意查询顺序: 如果在Outlook Express的地址薄中有内容，则检查地址时地址薄优先，如果在本地地址薄中找不到相应记录，然后再查询LDAP服务器。
3) 用下面的命令确信客户端与LDAP服务器有通讯,在服务器运行下面的命令，然后在OE中测试检查地址，你将会得到查询LDAP数据库的连接过程的输出。
# tcpdump port 389
Berkeley DB : http://www.oracle.com/technology/products/berkeley-db/db/index.html
下载BerkeleyDB
[root@rhas4min79 openldap-2.4.16]# tar zxvf openldap-db-4.7.25.tar.gz
[root@rhas4min79 openldap-2.4.16]# cd soft/db-4.7.25/build_unix/
[root@rhas4min79 openldap-2.4.16]# ../dist/configure --prefix=/usr/local/BerkeleyDB/
#make
#make install
BerkeleyDB安装结束，开始安装OPENLDAP，下载openldap
设置环境变量
export CPPFLAGS="-I/usr/local/BerkeleyDB/include"
export LDFLAGS="-L/usr/local/lib -L/usr/local/BerkeleyDB/lib -R/usr/local/BerkeleyDB/lib"
export LD_LIBRARY_PATH="/usr/local/BerkeleyDB/lib"
# tar zxvf openldap-2.4.16.tgz
# cd openldap-2.4.16
# ./configure --prefix=/usr/local/openldap
# make depend
# make
# make test
# make install
设置一个基本的OpenLDAP Server
一. 目的
本文旨在介绍如何安装OpenLDAP并且设置一个公司内部的集中化的邮件地址薄服务器供客户端查询。
基本上，OpenLDAPg还应用在其它许多方面，象集中化的用户帐号验证服务器，但邮件地址薄查询是最常用的。
二. 安装
从www.openldap.org下载最新的openldap软件包，按照编译和安装的步骤，依次运行：
#tar cvfz openldap-stable-20010524.tgz
#cd openldap-2.0.11
#./configure
#make depend
#make
#make test
#make install
我的操作环境是redhat 6.1，如果没有遇到任何错误，最后默认安装LDAP后台程序slapd到目录/usr/local/libexec；配置文件在目录/usr/local/etc/openldap/ 并且放各种OpenLDAP工具
ldapadd,ldapdelete,ldapmodify,ldapmodrdn,ldappasswd,ldapsearch在目录/usr/local/bin，运行时数据库在/usr/local/var/openldap-ldbm。
三. 设置
1) 更改配置文件/usr/local/etc/openldap/slapd.conf
在include /usr/local/etc/openldap/schema/core.schema这行后面加上下面的行，包括所有的方案。
include /usr/local/etc/openldap/schema/corba.schema
include /usr/local/etc/openldap/schema/cosine.schema
include /usr/local/etc/openldap/schema/inetorgperson.schema
include /usr/local/etc/openldap/schema/java.schema
include /usr/local/etc/openldap/schema/krb5-kdc.schema
include /usr/local/etc/openldap/schema/misc.schema
include /usr/local/etc/openldap/schema/nadf.schema
include /usr/local/etc/openldap/schema/nis.schema
include /usr/local/etc/openldap/schema/openldap.schema
2) 在文件slapd.conf的"ldbm database definitions"部分更改相应的suffix,rootdn行如下
database ldbm
suffix "o=yourdomain,c=us"
rootdn "cn=root,o=yourdomain,c=us"
rootpw secret
directory /usr/local/var/openldap-ldbm
有各种格式你可以用，这里我用的是o=yourdomain,c=us 说明你的公司域名和所在的国家或地区。
rootdn的格式安装后默认为cn=Manager,这里改为root完全是自己的喜好,这样符合Unix/Linux中root具有最高权限的传统。
3) 现在可以启动slapd了，运行/usr/local/libexec/slapd 。
可以考虑把/usr/local/bin and /usr/local/libexec加到搜索路径中，即加到/etc/profile
中的PATH行:
PATH="$PATH:/usr/X11R6/bin:/usr/local/bin:/usr/local/libexec"
这样下次登录后只需键入 slapd 。
4) 测试ldap server是否正常工作。
运行下面的命令检查是否有相应的输出。
#ldapsearch -x -b 'o=yourdomain,c=us' '(objectclass=*)'
陈绪先生注：有误，应该为
ldapsearch -x -b '' -s base '(objectclass=*)' namingContexts
或者
ldapsearch -x -b '' -s base '(objectclass=*)'
5) 编辑.ldif文本文件，用ldapadd添加记录进入LDAP数据库。
文件内容如下：
dn: o=yourdomain,c=us
objectclass: dcobject
objectclass: organization
o: yourdomain
dc: yourdomain
dn: cn=Jephe Wu,o=yourdomain,c=us
objectclass: inetorgperson
cn: Jephe Wu
sn: Wu
mail: jephe_wu@yourdomain.com
......more users......
依次类推，添加每个人的记录进入该文件中，注意对象类型 inetorgperson 至少必须要有cn和sn，这里我们用cn,sn,mail三项定义,这对我们的邮件地址薄功能来说已经足够。你还可以定义象mobile, homephone,pager......等等。
然后用下面的命令添加上面的.ldif文件进入LDAP数据库
#ldapadd -x -D "cn=root,o=yourdomain,c=us" -w secret -f "yourldiffilename"
注：上面的文件的第一部分"dn: o=yourdomain,c=us"是必须的，否则不能添加数据。
用你的公司的域名替换上面的"yourdomain"。
6) 设置Outlook Express, 允许用LDAP服务器查询邮件地址。
"工具/帐号/添加--目录服务"，填入你的服务器的IP地址或者主机全称域名，在下一个屏幕中选yes以允许用目录服务来查询地址，最后在"目录服务"栏中选中刚才设置的项目击“属性/高级",在"搜索库"中填入"o=yourdomain,c=us"。
Netscape请根据上面的信息设置相应的选项。
四. 常见使用问题
1) 能启动slapd 没有问题，但不能添加数据库，运行ldapadd添加时出错 "ldap_bind:cannot contact LDAP Server" 。
答: 最可能的原因是在/etc/hosts中没有127.0.0.1 localhost项目。
2) 注意查询顺序: 如果在Outlook Express的地址薄中有内容，则检查地址时地址薄优先，如果在本地地址薄中找不到相应记录，然后再查询LDAP服务器。
3) 用下面的命令确信客户端与LDAP服务器有通讯,在服务器运行下面的命令，然后在OE中测试检查地址，你将会得到查询LDAP数据库的连接过程的输出。
# tcpdump port 389
Compiling OpenLDAP on Cygwin
更多精彩请到 http://www.139ya.com
转自: http://the.taoofmac.com/space/OpenLDAP
Compiling OpenLDAP on Cygwin
OpenLDAP is an Open Source LDAPv3 implementation (clients, libraries, and servers).
Compiling it for Windows on recent versions of Cygwin without any extra libraries is simply a matter of doing:
./configure --disable-bdb --enable-ldbm --enable-ldap \
--enable-passwd --enable-shell
And then replacing bdb with ldbm for the database type in /usr/local/etc/openldap/slapd.conf.
转自: http://the.taoofmac.com/space/OpenLDAP
Compiling OpenLDAP on Cygwin
OpenLDAP is an Open Source LDAPv3 implementation (clients, libraries, and servers).
Compiling it for Windows on recent versions of Cygwin without any extra libraries is simply a matter of doing:
./configure --disable-bdb --enable-ldbm --enable-ldap \
--enable-passwd --enable-shell
And then replacing bdb with ldbm for the database type in /usr/local/etc/openldap/slapd.conf.
java异常机制介绍
更多精彩请到 http://www.139ya.com
java异常机制介绍 ： http://hwangita.blog.ccidnet.com/blog-htm-do-showone-uid-45279-itemid-137486-type-blog.html
java异常机制介绍
Java 语言要求 java 程序中（无论是谁写的代码），所有抛出（ throw ）的异常都必须是从 Throwable 派生而来。当然，实际的 Java 编程中，由于 JDK 平台已经为我们设计好了非常丰富和完整的异常对象分类模型。因此， java 程序员一般是不需要再重新定义自己的异常对象。而且即便是需要扩展自定义的异常对象，也往往会从 Exception 派生而来。所以，对于 java 程序员而言，它一般只需要在它的顶级函数中 catch(Exception ex) 就可以捕获出所有的异常对象。 所有异常对象的根基类是 Throwable ， Throwable 从 Object 直接继承而来（这是 java 系统所强制要求的），并且它实现了 Serializable 接口（这为所有的异常对象都能够轻松跨越 Java 组件系统做好了最充分的物质准备）。从 Throwable 直接派生出的异常类有 Exception 和 Error 。 Exception 是 java 程序员所最熟悉的，它一般代表了真正实际意义上的异常对象的根基类。也即是说， Exception 和从它派生而来的所有异常都是应用程序能够 catch 到的，并且可以进行异常错误恢复处理的异常类型。而 Error 则表示 Java 系统中出现了一个非常严重的异常错误，并且这个错误可能是应用程序所不能恢复的，例如 LinkageError ，或 ThreadDeath 等。
首先还是看一个例子吧！代码如下：
import java.io.*;
public class Trans
{
public static void main(String[] args)
{
try
{
BufferedReader rd=null;
Writer wr=null;
try
{
File srcFile = new File((args[0]));
File dstFile = new File((args[1]));
rd = new BufferedReader(new InputStreamReader(new FileInputStream(srcFile), args[2]));
wr = new OutputStreamWriter(new FileOutputStream(dstFile), args[3]);
// 注意下面这条语句，它有什么问题吗？
if (rd == null || wr == null) throw new Exception("error! test!");
while(true)
{
String sLine = rd.readLine();
if(sLine == null) break;
wr.write(sLine);
wr.write("\r\n");
}
}
finally
{
wr.flush();
wr.close();
rd.close();
}
}
catch(IOException ex)
{
ex.printStackTrace();
}
}
}
熟悉 java 语言的程序员朋友们，你们认为上面的程序有什么问题吗？编译能通过吗？如果不能，那么原因又是为何呢？好了，有了自己的分析和预期之后，不妨亲自动手编译一下上面的小程序，呵呵！结果确实如您所料？是的，的确是编译时报错了，错误信息如下：
E:\Trans.java:20: unreported exception java.lang.Exception; must be caught or declared to be thrown
if (rd == null || wr == null) throw new Exception("error! test!");
1 error
上面这种编译错误信息，相信 Java 程序员肯定见过（可能还是屡见不鲜！）！
相信老练一些的 Java 程序员一定非常清楚上述编译出错的原因。那就是如错误信息中（“ must be caught ”）描述的那样， 在 Java 的异常处理模型中，要求所有被抛出的异常都必须要有对应的“异常处理模块” 。也即是说，如果你在程序中 throw 出一个异常，那么在你的程序中（函数中）就必须要 catch 这个异常（处理这个异常）。例如上面的例子中，你在第 20 行代码处，抛出了一个 Exception 类型的异常，但是在该函数中，却没有 catch 并处理掉此异常的地方。因此，这样的程序即便是能够编译通过，那么运行时也是致命的（可能导致程序的崩溃），所以， Java 语言干脆在编译时就尽可能地检查（并卡住）这种本不应该出现的错误，这无疑对提高程序的可靠性大有帮助。
但是，在 Java 语言中，这就是必须的。 如果一个函数中，它运行时可能会向上层调用者函数抛出一个异常，那么，它就必须在该函数的声明中显式的注明（采用 throws 关键字） 。还记得刚才那条编译错误信息吗？“ must be caught or declared to be thrown ”，其中“ must be caught ”上面已经解释了，而后半部分呢？“ declared to be thrown ”是指何意呢？其实指的就是“必须显式地声明某个函数可能会向外部抛出一个异常”，也即是说，如果一个函数内部，它可能抛出了一种类型的异常，但该函数内部并不想（或不宜） catch 并处理这种类型的异常，此时，它就必须使用 throws 关键字来声明该函数可能会向外部抛出一个异常，以便于该函数的调用者知晓并能够及时处理这种类型的异常。下面列出了这几种情况的比较，代码如下：
// 示例程序 1 ，这种写法能够编译通过
package com.ginger.exception;
import java.io.*;
public class Trans {
public static void main(String[] args) {
try {
test();
} catch (Exception ex) {
ex.printStackTrace();
}
}
static void test() {
try {
throw new Exception("To show Exception Successed");
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
// 示例程序 2 ，这种写法就不能够编译通过
import java.io.*;
public class Trans {
public static void main(String[] args) {
try {
test();
}
// 虽然这里能够捕获到 Exception 类型的异常
catch (Exception ex) {
ex.printStackTrace();
}
}
static void test() {
throw new Exception("test");
}
}
// 示例程序 3 ，这种写法又能够被编译通过
import java.io.*;
public class Trans
{
public static void main(String[] args)
{
try
{
test();
}
catch(Exception ex)
{
ex.printStackTrace();
}
}
// 由于函数声明了可能抛出 Exception 类型的异常
static void test() throws Exception
{
throw new Exception("test");
}
}
// 示例程序 4 ，它又不能够被编译通过了
import java.io.*;
public class Trans
{
public static void main(String[] args)
{
try
{
// 虽然 test() 函数并没有真正抛出一个 Exception 类型的异常
// 但是由于它函数声明时，表示它可能抛出一个 Exception 类型的异常
// 所以，这里仍然不能被编译通过。
// 呵呵！体会到了 Java 异常处理模型的严谨吧！
test();
}
catch(IOException ex)
{
ex.printStackTrace();
}
}
static void test() throws Exception
{
}
}
总结：用throw时，一定要在函数体内要有对应的catch（），意思是说，抛出IOException e，你就要catch IOException,抛出Exception，就要catch Exception；要对应。
用throws时，上层调用者去catch()就可以了.
不知上面几个有联系的示例是否能够给大家带来“豁然开朗”的感觉，坦率的说， Java 提供的异常处理模型并不复杂，相信太多太多 Java 程序员有着比我更深刻的认识。最后，补充一种例外情况，请看如下代码：
import java.io.*;
public class Trans {
public static void main(String[] args) {
try {
test();
} catch (Exception ex) {
ex.printStackTrace();
}
}
static void test() throws Error {
throw new Error(" 故意抛出一个 Error");
}
}
朋友们！上面的程序能被编译通过吗？注意，按照刚才上面所总结出的规律：在 Java 的异常处理模型中，要求所有被抛出的异常都必须要有对应的 catch 块！那么上面的程序肯定不能被编译通过，因为 Error 和 Exception 都是从 Throwable 直接派生而来，而 test 函数声明了它可能抛出 Error 类型的异常，但在 main 函数中却并没有 catch(Error) 或 catch(Throwable) 块，所以它理当是会编译出错的！真的吗？不妨试试！呵呵！结果并非我们之预料，而它恰恰是正确编译通过了。为何？ WHY ？ WHY ？
其实，原因很简单，那就是因为 Error 异常的特殊性。 Java 异常处理模型中规定： Error 和从它派生而来的所有异常，都表示系统中出现了一个非常严重的异常错误，并且这个错误可能是应用程序所不能恢复的（其实这在前面的内容中已提到过）。因此，如果系统中真的出现了一个 Error 类型的异常，那么则表明，系统已处于崩溃不可恢复的状态中，此时，作为编写 Java 应用程序的你，已经是没有必要（也没能力）来处理此等异常错误。所以， javac 编译器就没有必要来保证：“在编译时，所有的 Error 异常都有其对应的错误处理模块”。当然， Error 类型的异常一般都是由系统遇到致命的错误时所抛出的，它最后也由 Java 虚拟机所处理。而作为 Java 程序员的你，可能永远也不会考虑抛出一个 Error 类型的异常。因此 Error 是一个特例情况！
特别关注一下 RuntimeException
上面刚刚讨论了一下 Error 类型的异常处理情况， Java 程序员一般无须关注它（处理这种异常）。另外，其实在 Exception 类型的异常对象中，也存在一种比较特别的“异常”类型，那就是 RuntimeException ，虽然它是直接从 Exception 派生而来，但是 Java 编译器（ javac ）对 RuntimeException 却是特殊待遇，而且是照顾有加。不信，看看下面的两个示例吧！代码如下：
// 示例程序 1
// 它不能编译通过，我们可以理解
import java.io.*;
public class Trans {
public static void main(String[] args) {
test();
}
static void test() {
// 注意这条语句
throw new Exception(" 故意抛出一个 Exception");
}
}
// 示例程序 2
// 可它却为什么能够编译通过呢？
import java.io.*;
public class Trans {
public static void main(String[] args) {
test();
}
static void test() {
// 注意这条语句
throw new RuntimeException(" 故意抛出一个 RuntimeException");
}
}
对上面两个相当类似的程序， javac 编译时却遭遇了两种截然不同的处理，按理说，第 2 个示例程序也应该像第 1 个示例程序那样，编译时报错！但是 javac 编译它时，却例外地让它通过它，而且在运行时， java 虚拟机也捕获到了这个异常，并且会在 console 打印出详细的异常信息。运行结果如下：
java.lang.RuntimeException: 故意抛出一个 RuntimeException
at Trans.test(Trans.java:13)
at Trans.main(Trans.java:8)
Exception in thread "main"
为什么对于 RuntimeException 类型的异常（以及从它派生而出的异常类型）， javac 和 java 虚拟机都特殊处理呢？要知道，这可是与“ Java 异常处理模型更严谨和更安全”的设计原则相抵触的呀！究竟是为何呢？这简直让人不法理解呀！
只不过， Java 语言中， RuntimeException 被统一纳入到了 Java 语言和 JDK 的规范之中。请看如下代码，来验证一下我们的理解！
import java.io.*;
public class Trans
{
public static void main(String[] args)
{
test();
}
static void test()
{
int i = 4;
int j = 0;
// 运行时，这里将触发了一个 ArithmeticException
// ArithmeticException 从 RuntimeException 派生而来
System.out.println("i / j = " + i / j);
}
}
运行结果如下：
java.lang.ArithmeticException: / by zero
at Trans.test(Trans.java:16)
at Trans.main(Trans.java:8)
Exception in thread "main"
又如下面的例子，也会产生一个 RuntimeException ，代码如下：
import java.io.*;
public class Trans
{
public static void main(String[] args)
{
test();
}
static void test()
{
String str = null;
// 运行时，这里将触发了一个 NullPointerException
// NullPointerException 从 RuntimeException 派生而来
str.compareTo("abc");
}
}
所以，针对 RuntimeException 类型的异常， javac 是无法通过编译时的静态语法检测来判断到底哪些函数（或哪些区域的代码）可能抛出这类异常（这完全取决于运行时状态，或者说运行态所决定的），也正因为如此， Java 异常处理模型中的“ must be caught or declared to be thrown ”规则也不适用于 RuntimeException （所以才有前面所提到过的奇怪编译现象，这也属于特殊规则吧）。但是， Java 虚拟机却需要有效地捕获并处理此类异常。当然， RuntimeException 也可以被程序员显式地抛出，而且为了程序的可靠性，对一些可能出现“运行时异常（ RuntimeException ）”的代码区域，程序员最好能够及时地处理这些意外的异常，也即通过 catch(RuntimeExcetion) 或 catch(Exception) 来捕获它们。如下面的示例程序，代码如下：
import java.io.*;
public class Trans
{
public static void main(String[] args)
{
try
{
test();
}
// 在上层的调用函数中，最好捕获所有的 Exception 异常！
catch(Exception e)
{
System.out.println("go here!");
e.printStackTrace();
}
}
// 这里最好显式地声明一下，表明该函数可能抛出 RuntimeException
static void test() throws RuntimeException
{
String str = null;
// 运行时，这里将触发了一个 NullPointerException
// NullPointerException 从 RuntimeException 派生而来
str.compareTo("abc");
}
}
java异常机制介绍 ： http://hwangita.blog.ccidnet.com/blog-htm-do-showone-uid-45279-itemid-137486-type-blog.html
java异常机制介绍
Java 语言要求 java 程序中（无论是谁写的代码），所有抛出（ throw ）的异常都必须是从 Throwable 派生而来。当然，实际的 Java 编程中，由于 JDK 平台已经为我们设计好了非常丰富和完整的异常对象分类模型。因此， java 程序员一般是不需要再重新定义自己的异常对象。而且即便是需要扩展自定义的异常对象，也往往会从 Exception 派生而来。所以，对于 java 程序员而言，它一般只需要在它的顶级函数中 catch(Exception ex) 就可以捕获出所有的异常对象。 所有异常对象的根基类是 Throwable ， Throwable 从 Object 直接继承而来（这是 java 系统所强制要求的），并且它实现了 Serializable 接口（这为所有的异常对象都能够轻松跨越 Java 组件系统做好了最充分的物质准备）。从 Throwable 直接派生出的异常类有 Exception 和 Error 。 Exception 是 java 程序员所最熟悉的，它一般代表了真正实际意义上的异常对象的根基类。也即是说， Exception 和从它派生而来的所有异常都是应用程序能够 catch 到的，并且可以进行异常错误恢复处理的异常类型。而 Error 则表示 Java 系统中出现了一个非常严重的异常错误，并且这个错误可能是应用程序所不能恢复的，例如 LinkageError ，或 ThreadDeath 等。
首先还是看一个例子吧！代码如下：
import java.io.*;
public class Trans
{
public static void main(String[] args)
{
try
{
BufferedReader rd=null;
Writer wr=null;
try
{
File srcFile = new File((args[0]));
File dstFile = new File((args[1]));
rd = new BufferedReader(new InputStreamReader(new FileInputStream(srcFile), args[2]));
wr = new OutputStreamWriter(new FileOutputStream(dstFile), args[3]);
// 注意下面这条语句，它有什么问题吗？
if (rd == null || wr == null) throw new Exception("error! test!");
while(true)
{
String sLine = rd.readLine();
if(sLine == null) break;
wr.write(sLine);
wr.write("\r\n");
}
}
finally
{
wr.flush();
wr.close();
rd.close();
}
}
catch(IOException ex)
{
ex.printStackTrace();
}
}
}
熟悉 java 语言的程序员朋友们，你们认为上面的程序有什么问题吗？编译能通过吗？如果不能，那么原因又是为何呢？好了，有了自己的分析和预期之后，不妨亲自动手编译一下上面的小程序，呵呵！结果确实如您所料？是的，的确是编译时报错了，错误信息如下：
E:\Trans.java:20: unreported exception java.lang.Exception; must be caught or declared to be thrown
if (rd == null || wr == null) throw new Exception("error! test!");
1 error
上面这种编译错误信息，相信 Java 程序员肯定见过（可能还是屡见不鲜！）！
相信老练一些的 Java 程序员一定非常清楚上述编译出错的原因。那就是如错误信息中（“ must be caught ”）描述的那样， 在 Java 的异常处理模型中，要求所有被抛出的异常都必须要有对应的“异常处理模块” 。也即是说，如果你在程序中 throw 出一个异常，那么在你的程序中（函数中）就必须要 catch 这个异常（处理这个异常）。例如上面的例子中，你在第 20 行代码处，抛出了一个 Exception 类型的异常，但是在该函数中，却没有 catch 并处理掉此异常的地方。因此，这样的程序即便是能够编译通过，那么运行时也是致命的（可能导致程序的崩溃），所以， Java 语言干脆在编译时就尽可能地检查（并卡住）这种本不应该出现的错误，这无疑对提高程序的可靠性大有帮助。
但是，在 Java 语言中，这就是必须的。 如果一个函数中，它运行时可能会向上层调用者函数抛出一个异常，那么，它就必须在该函数的声明中显式的注明（采用 throws 关键字） 。还记得刚才那条编译错误信息吗？“ must be caught or declared to be thrown ”，其中“ must be caught ”上面已经解释了，而后半部分呢？“ declared to be thrown ”是指何意呢？其实指的就是“必须显式地声明某个函数可能会向外部抛出一个异常”，也即是说，如果一个函数内部，它可能抛出了一种类型的异常，但该函数内部并不想（或不宜） catch 并处理这种类型的异常，此时，它就必须使用 throws 关键字来声明该函数可能会向外部抛出一个异常，以便于该函数的调用者知晓并能够及时处理这种类型的异常。下面列出了这几种情况的比较，代码如下：
// 示例程序 1 ，这种写法能够编译通过
package com.ginger.exception;
import java.io.*;
public class Trans {
public static void main(String[] args) {
try {
test();
} catch (Exception ex) {
ex.printStackTrace();
}
}
static void test() {
try {
throw new Exception("To show Exception Successed");
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
// 示例程序 2 ，这种写法就不能够编译通过
import java.io.*;
public class Trans {
public static void main(String[] args) {
try {
test();
}
// 虽然这里能够捕获到 Exception 类型的异常
catch (Exception ex) {
ex.printStackTrace();
}
}
static void test() {
throw new Exception("test");
}
}
// 示例程序 3 ，这种写法又能够被编译通过
import java.io.*;
public class Trans
{
public static void main(String[] args)
{
try
{
test();
}
catch(Exception ex)
{
ex.printStackTrace();
}
}
// 由于函数声明了可能抛出 Exception 类型的异常
static void test() throws Exception
{
throw new Exception("test");
}
}
// 示例程序 4 ，它又不能够被编译通过了
import java.io.*;
public class Trans
{
public static void main(String[] args)
{
try
{
// 虽然 test() 函数并没有真正抛出一个 Exception 类型的异常
// 但是由于它函数声明时，表示它可能抛出一个 Exception 类型的异常
// 所以，这里仍然不能被编译通过。
// 呵呵！体会到了 Java 异常处理模型的严谨吧！
test();
}
catch(IOException ex)
{
ex.printStackTrace();
}
}
static void test() throws Exception
{
}
}
总结：用throw时，一定要在函数体内要有对应的catch（），意思是说，抛出IOException e，你就要catch IOException,抛出Exception，就要catch Exception；要对应。
用throws时，上层调用者去catch()就可以了.
不知上面几个有联系的示例是否能够给大家带来“豁然开朗”的感觉，坦率的说， Java 提供的异常处理模型并不复杂，相信太多太多 Java 程序员有着比我更深刻的认识。最后，补充一种例外情况，请看如下代码：
import java.io.*;
public class Trans {
public static void main(String[] args) {
try {
test();
} catch (Exception ex) {
ex.printStackTrace();
}
}
static void test() throws Error {
throw new Error(" 故意抛出一个 Error");
}
}
朋友们！上面的程序能被编译通过吗？注意，按照刚才上面所总结出的规律：在 Java 的异常处理模型中，要求所有被抛出的异常都必须要有对应的 catch 块！那么上面的程序肯定不能被编译通过，因为 Error 和 Exception 都是从 Throwable 直接派生而来，而 test 函数声明了它可能抛出 Error 类型的异常，但在 main 函数中却并没有 catch(Error) 或 catch(Throwable) 块，所以它理当是会编译出错的！真的吗？不妨试试！呵呵！结果并非我们之预料，而它恰恰是正确编译通过了。为何？ WHY ？ WHY ？
其实，原因很简单，那就是因为 Error 异常的特殊性。 Java 异常处理模型中规定： Error 和从它派生而来的所有异常，都表示系统中出现了一个非常严重的异常错误，并且这个错误可能是应用程序所不能恢复的（其实这在前面的内容中已提到过）。因此，如果系统中真的出现了一个 Error 类型的异常，那么则表明，系统已处于崩溃不可恢复的状态中，此时，作为编写 Java 应用程序的你，已经是没有必要（也没能力）来处理此等异常错误。所以， javac 编译器就没有必要来保证：“在编译时，所有的 Error 异常都有其对应的错误处理模块”。当然， Error 类型的异常一般都是由系统遇到致命的错误时所抛出的，它最后也由 Java 虚拟机所处理。而作为 Java 程序员的你，可能永远也不会考虑抛出一个 Error 类型的异常。因此 Error 是一个特例情况！
特别关注一下 RuntimeException
上面刚刚讨论了一下 Error 类型的异常处理情况， Java 程序员一般无须关注它（处理这种异常）。另外，其实在 Exception 类型的异常对象中，也存在一种比较特别的“异常”类型，那就是 RuntimeException ，虽然它是直接从 Exception 派生而来，但是 Java 编译器（ javac ）对 RuntimeException 却是特殊待遇，而且是照顾有加。不信，看看下面的两个示例吧！代码如下：
// 示例程序 1
// 它不能编译通过，我们可以理解
import java.io.*;
public class Trans {
public static void main(String[] args) {
test();
}
static void test() {
// 注意这条语句
throw new Exception(" 故意抛出一个 Exception");
}
}
// 示例程序 2
// 可它却为什么能够编译通过呢？
import java.io.*;
public class Trans {
public static void main(String[] args) {
test();
}
static void test() {
// 注意这条语句
throw new RuntimeException(" 故意抛出一个 RuntimeException");
}
}
对上面两个相当类似的程序， javac 编译时却遭遇了两种截然不同的处理，按理说，第 2 个示例程序也应该像第 1 个示例程序那样，编译时报错！但是 javac 编译它时，却例外地让它通过它，而且在运行时， java 虚拟机也捕获到了这个异常，并且会在 console 打印出详细的异常信息。运行结果如下：
java.lang.RuntimeException: 故意抛出一个 RuntimeException
at Trans.test(Trans.java:13)
at Trans.main(Trans.java:8)
Exception in thread "main"
为什么对于 RuntimeException 类型的异常（以及从它派生而出的异常类型）， javac 和 java 虚拟机都特殊处理呢？要知道，这可是与“ Java 异常处理模型更严谨和更安全”的设计原则相抵触的呀！究竟是为何呢？这简直让人不法理解呀！
只不过， Java 语言中， RuntimeException 被统一纳入到了 Java 语言和 JDK 的规范之中。请看如下代码，来验证一下我们的理解！
import java.io.*;
public class Trans
{
public static void main(String[] args)
{
test();
}
static void test()
{
int i = 4;
int j = 0;
// 运行时，这里将触发了一个 ArithmeticException
// ArithmeticException 从 RuntimeException 派生而来
System.out.println("i / j = " + i / j);
}
}
运行结果如下：
java.lang.ArithmeticException: / by zero
at Trans.test(Trans.java:16)
at Trans.main(Trans.java:8)
Exception in thread "main"
又如下面的例子，也会产生一个 RuntimeException ，代码如下：
import java.io.*;
public class Trans
{
public static void main(String[] args)
{
test();
}
static void test()
{
String str = null;
// 运行时，这里将触发了一个 NullPointerException
// NullPointerException 从 RuntimeException 派生而来
str.compareTo("abc");
}
}
所以，针对 RuntimeException 类型的异常， javac 是无法通过编译时的静态语法检测来判断到底哪些函数（或哪些区域的代码）可能抛出这类异常（这完全取决于运行时状态，或者说运行态所决定的），也正因为如此， Java 异常处理模型中的“ must be caught or declared to be thrown ”规则也不适用于 RuntimeException （所以才有前面所提到过的奇怪编译现象，这也属于特殊规则吧）。但是， Java 虚拟机却需要有效地捕获并处理此类异常。当然， RuntimeException 也可以被程序员显式地抛出，而且为了程序的可靠性，对一些可能出现“运行时异常（ RuntimeException ）”的代码区域，程序员最好能够及时地处理这些意外的异常，也即通过 catch(RuntimeExcetion) 或 catch(Exception) 来捕获它们。如下面的示例程序，代码如下：
import java.io.*;
public class Trans
{
public static void main(String[] args)
{
try
{
test();
}
// 在上层的调用函数中，最好捕获所有的 Exception 异常！
catch(Exception e)
{
System.out.println("go here!");
e.printStackTrace();
}
}
// 这里最好显式地声明一下，表明该函数可能抛出 RuntimeException
static void test() throws RuntimeException
{
String str = null;
// 运行时，这里将触发了一个 NullPointerException
// NullPointerException 从 RuntimeException 派生而来
str.compareTo("abc");
}
}
Java异常处理机制的详细讲解和使用技巧
更多精彩请到 http://www.139ya.com
Java异常处理机制的详细讲解和使用技巧： http://www.cn-java.com/www1/?action-viewnews-itemid-3730
1. 异常机制
1.1
异常机制是指当程序出现错误后，程序如何处理。具体来说，异常机制提供了程序退出的安全通道。当出现错误后，程序执行的流程发生改变，程序的控制权转移到异常处理器。
1.2
传统的处理异常的办法是，函数返回一个特殊的结果来表示出现异常（通常这个特殊结果是大家约定俗称的），调用该函数的程序负责检查并分析函数返回的结果。这样做有如下的弊端：例如函数返回-1代表出现异常，但是如果函数确实要返回-1这个正确的值时就会出现混淆；可读性降低，将程序代码与处理异常的代码混爹在一起；由调用函数的程序来分析错误，这就要求客户程序员对库函数有很深的了解。
1.3 异常处理的流程
1.3.1 遇到错误，方法立即结束，并不返回一个值；同时，抛出一个异常对象
1.3.2 调用该方法的程序也不会继续执行下去，而是搜索一个可以处理该异常的异常处理器，并执行其中的代码
2 异常的分类
2.1 异常的分类
2.1.1
异常的继承结构：基类为Throwable，Error和Exception继承Throwable，RuntimeException和IOException等继承Exception，具体的RuntimeException继承RuntimeException。
2.1.2
Error和RuntimeException及其子类成为未检查异常（unchecked），其它异常成为已检查异常（checked）。
2.2 每个类型的异常的特点
2.2.1 Error体系
Error类体系描述了Java运行系统中的内部错误以及资源耗尽的情形。应用程序不应该抛出这种类型的对象（一般是由虚拟机抛出）。如果出现这种错误，除了尽力使程序安全退出外，在其他方面是无能为力的。所以，在进行程序设计时，应该更关注Exception体系。
2.2.2 Exception体系
Exception体系包括RuntimeException体系和其他非RuntimeException的体系
2.2.2.1 RuntimeException
RuntimeException体系包括错误的类型转换、数组越界访问和试图访问空指针等等。处理RuntimeException的原则是：如果出现RuntimeException，那么一定是程序员的错误。例如，可以通过检查数组下标和数组边界来避免数组越界访问异常。
2.2.2.2 其他（IOException等等）
这类异常一般是外部错误，例如试图从文件尾后读取数据等，这并不是程序本身的错误，而是在应用环境中出现的外部错误。
2.3 与C++异常分类的不同
2.3.1
其实，Java中RuntimeException这个类名起的并不恰当，因为任何异常都是运行时出现的。（在编译时出现的错误并不是异常，换句话说，异常就是为了解决程序运行时出现的的错误）。
2.3.2
C++中logic_error与Java中的RuntimeException是等价的，而runtime_error与Java中非RuntimeException类型的异常是等价的。
3 异常的使用方法
3.1 声明方法抛出异常
3.1.1 语法：throws（略）
3.1.2 为什么要声明方法抛出异常？
方法是否抛出异常与方法返回值的类型一样重要。假设方法抛出异常确没有声明该方法将抛出异常，那么客户程序员可以调用这个方法而且不用编写处理异常的代码。那么，一旦出现异常，那么这个异常就没有合适的异常控制器来解决。
3.1.3 为什么抛出的异常一定是已检查异常？
RuntimeException与Error可以在任何代码中产生，它们不需要由程序员显示的抛出，一旦出现错误，那么相应的异常会被自动抛出。而已检查异常是由程序员抛出的，这分为两种情况：客户程序员调用会抛出异常的库函数（库函数的异常由库程序员抛出）；客户程序员自己使用throw语句抛出异常。遇到Error，程序员一般是无能为力的；遇到RuntimeException，那么一定是程序存在逻辑错误，要对程序进行修改（相当于调试的一种方法）；只有已检查异常才是程序员所关心的，程序应该且仅应该抛出或处理已检查异常。
3.1.4
注意：覆盖父类某方法的子类方法不能抛出比父类方法更多的异常，所以，有时设计父类的方法时会声明抛出异常，但实际的实现方法的代码却并不抛出异常，这样做的目的就是为了方便子类方法覆盖父类方法时可以抛出异常。
3.2 如何抛出异常
3.2.1 语法：throw（略）
3.2.2 抛出什么异常？
对于一个异常对象，真正有用的信息时异常的对象类型，而异常对象本身毫无意义。比如一个异常对象的类型是ClassCastException，那么这个类名就是唯一有用的信息。所以，在选择抛出什么异常时，最关键的就是选择异常的类名能够明确说明异常情况的类。
3.2.3
异常对象通常有两种构造函数：一种是无参数的构造函数；另一种是带一个字符串的构造函数，这个字符串将作为这个异常对象除了类型名以外的额外说明。
3.2.4
创建自己的异常：当Java内置的异常都不能明确的说明异常情况的时候，需要创建自己的异常。需要注意的是，唯一有用的就是类型名这个信息，所以不要在异常类的设计上花费精力。
3.3 捕获异常
如果一个异常没有被处理，那么，对于一个非图形界面的程序而言，该程序会被中止并输出异常信息；对于一个图形界面程序，也会输出异常的信息，但是程序并不中止，而是返回用Ы缑娲
Java异常处理机制的详细讲解和使用技巧： http://www.cn-java.com/www1/?action-viewnews-itemid-3730
1. 异常机制
1.1
异常机制是指当程序出现错误后，程序如何处理。具体来说，异常机制提供了程序退出的安全通道。当出现错误后，程序执行的流程发生改变，程序的控制权转移到异常处理器。
1.2
传统的处理异常的办法是，函数返回一个特殊的结果来表示出现异常（通常这个特殊结果是大家约定俗称的），调用该函数的程序负责检查并分析函数返回的结果。这样做有如下的弊端：例如函数返回-1代表出现异常，但是如果函数确实要返回-1这个正确的值时就会出现混淆；可读性降低，将程序代码与处理异常的代码混爹在一起；由调用函数的程序来分析错误，这就要求客户程序员对库函数有很深的了解。
1.3 异常处理的流程
1.3.1 遇到错误，方法立即结束，并不返回一个值；同时，抛出一个异常对象
1.3.2 调用该方法的程序也不会继续执行下去，而是搜索一个可以处理该异常的异常处理器，并执行其中的代码
2 异常的分类
2.1 异常的分类
2.1.1
异常的继承结构：基类为Throwable，Error和Exception继承Throwable，RuntimeException和IOException等继承Exception，具体的RuntimeException继承RuntimeException。
2.1.2
Error和RuntimeException及其子类成为未检查异常（unchecked），其它异常成为已检查异常（checked）。
2.2 每个类型的异常的特点
2.2.1 Error体系
Error类体系描述了Java运行系统中的内部错误以及资源耗尽的情形。应用程序不应该抛出这种类型的对象（一般是由虚拟机抛出）。如果出现这种错误，除了尽力使程序安全退出外，在其他方面是无能为力的。所以，在进行程序设计时，应该更关注Exception体系。
2.2.2 Exception体系
Exception体系包括RuntimeException体系和其他非RuntimeException的体系
2.2.2.1 RuntimeException
RuntimeException体系包括错误的类型转换、数组越界访问和试图访问空指针等等。处理RuntimeException的原则是：如果出现RuntimeException，那么一定是程序员的错误。例如，可以通过检查数组下标和数组边界来避免数组越界访问异常。
2.2.2.2 其他（IOException等等）
这类异常一般是外部错误，例如试图从文件尾后读取数据等，这并不是程序本身的错误，而是在应用环境中出现的外部错误。
2.3 与C++异常分类的不同
2.3.1
其实，Java中RuntimeException这个类名起的并不恰当，因为任何异常都是运行时出现的。（在编译时出现的错误并不是异常，换句话说，异常就是为了解决程序运行时出现的的错误）。
2.3.2
C++中logic_error与Java中的RuntimeException是等价的，而runtime_error与Java中非RuntimeException类型的异常是等价的。
3 异常的使用方法
3.1 声明方法抛出异常
3.1.1 语法：throws（略）
3.1.2 为什么要声明方法抛出异常？
方法是否抛出异常与方法返回值的类型一样重要。假设方法抛出异常确没有声明该方法将抛出异常，那么客户程序员可以调用这个方法而且不用编写处理异常的代码。那么，一旦出现异常，那么这个异常就没有合适的异常控制器来解决。
3.1.3 为什么抛出的异常一定是已检查异常？
RuntimeException与Error可以在任何代码中产生，它们不需要由程序员显示的抛出，一旦出现错误，那么相应的异常会被自动抛出。而已检查异常是由程序员抛出的，这分为两种情况：客户程序员调用会抛出异常的库函数（库函数的异常由库程序员抛出）；客户程序员自己使用throw语句抛出异常。遇到Error，程序员一般是无能为力的；遇到RuntimeException，那么一定是程序存在逻辑错误，要对程序进行修改（相当于调试的一种方法）；只有已检查异常才是程序员所关心的，程序应该且仅应该抛出或处理已检查异常。
3.1.4
注意：覆盖父类某方法的子类方法不能抛出比父类方法更多的异常，所以，有时设计父类的方法时会声明抛出异常，但实际的实现方法的代码却并不抛出异常，这样做的目的就是为了方便子类方法覆盖父类方法时可以抛出异常。
3.2 如何抛出异常
3.2.1 语法：throw（略）
3.2.2 抛出什么异常？
对于一个异常对象，真正有用的信息时异常的对象类型，而异常对象本身毫无意义。比如一个异常对象的类型是ClassCastException，那么这个类名就是唯一有用的信息。所以，在选择抛出什么异常时，最关键的就是选择异常的类名能够明确说明异常情况的类。
3.2.3
异常对象通常有两种构造函数：一种是无参数的构造函数；另一种是带一个字符串的构造函数，这个字符串将作为这个异常对象除了类型名以外的额外说明。
3.2.4
创建自己的异常：当Java内置的异常都不能明确的说明异常情况的时候，需要创建自己的异常。需要注意的是，唯一有用的就是类型名这个信息，所以不要在异常类的设计上花费精力。
3.3 捕获异常
如果一个异常没有被处理，那么，对于一个非图形界面的程序而言，该程序会被中止并输出异常信息；对于一个图形界面程序，也会输出异常的信息，但是程序并不中止，而是返回用Ы缑娲
LDAP 基本概念
更多精彩请到 http://www.139ya.com
http://tldp.org/HOWTO/LDAP-HOWTO/index.html
Appendix E: LDAP - Object Classes and Attributes： http://www.zytrax.com/books/ldap/ape/
Tips for LDAP Users： http://java.sun.com/products/jndi/tutorial/ldap/index.html
OpenLDAP Setup Overview: http://jamesthornton.com/redhat/linux/9/Reference-Guide/s1-ldap-quickstart.html
A Quick-Start Guide : http://www.openldap.org/doc/admin24/quickstart.html
LDAP Linux HOWTO : http://www.redhat.com/mirrors/LDP/HOWTO/LDAP-HOWTO/
dn ：一条记录的位置
dc ：一条记录所属区域
ou ：一条记录所属组织
cn/uid：一条记录的名字/ID
http://tldp.org/HOWTO/LDAP-HOWTO/index.html
Appendix E: LDAP - Object Classes and Attributes： http://www.zytrax.com/books/ldap/ape/
Tips for LDAP Users： http://java.sun.com/products/jndi/tutorial/ldap/index.html
OpenLDAP Setup Overview: http://jamesthornton.com/redhat/linux/9/Reference-Guide/s1-ldap-quickstart.html
A Quick-Start Guide : http://www.openldap.org/doc/admin24/quickstart.html
LDAP Linux HOWTO : http://www.redhat.com/mirrors/LDP/HOWTO/LDAP-HOWTO/
dn ：一条记录的位置
dc ：一条记录所属区域
ou ：一条记录所属组织
cn/uid：一条记录的名字/ID
LDAP 查询基本知识
更多精彩请到 http://www.139ya.com
转自: http://www.cnblogs.com/xray2005/archive/2008/05/07/1187504.html
LDAP 查询基本知识
基本 LDAP 语法
•
=（等于）
此 LDAP 参数表明某个属性等于某个值的条件得到满足。例如，如果希望查找“名“属性为“John”的所有对象，可以使用：
(givenName=John)
这会返回“名”属性为“John”的所有对象。圆括号是必需的，以便强调 LDAP 语句的开始和结束。
•
&（逻辑与）
如果具有多个条件并且希望全部条件都得到满足，则可使用此语法。例如，如果希望查找居住在 Dallas 并且“名”为“John”的所有人员，可以使用：
(&(givenName=John)(l=Dallas))
请注意，每个参数都被属于其自己的圆括号括起来。整个 LDAP 语句必须包括在一对主圆括号中。操作符 & 表明，只有每个参数都为真，才会将此筛选条件应用到要查询的对象。
•
!（逻辑非）
此操作符用来排除具有特定属性的对象。假定您需要查找“名”为“John”的对象以外的所有对象。则应使用如下语句：
(!givenName=John)
此语句将查找“名”不为“John”的所有对象。请注意：! 操作符紧邻参数的前面，并且位于参数的圆括号内。由于本语句只有一个参数，因此使用圆括号将其括起以示说明。
•
*（通配符）
可使用通配符表示值可以等于任何值。使用它的情况可能是：您希望查找具有职务头衔的所有对象。为此，可以使用：
(title=*)
这会返回“title”属性包含内容的所有对象。另一个例子是：您知道某个对象的“名”属性的开头两个字母是“Jo”。那么，可以使用如下语法进行查找：
(givenName=Jo*)
这会返回“名”以“Jo”开头的所有对象。
•
以下是 LDAP 语法的高级使用示例：
•
您需要一个筛选条件，用来查找居住在 Dallas 或 Austin，并且名为“John”的所有对象。使用的语法应当是：
(&(givenName=John)(|(l=Dallas)(l=Austin)))
•
您发现应用程序日志中有 9,548 个事件，因此需要查找导致这些日志事件的所有对象。在此情况下，您需要查找所有被禁用的用户 (msExchUserAccountControl=2)，这些用户的 msExchMasterAccountSID 没有值。使用的语法应当是：
(&(msExchUserAccountControl=2)(!msExchMasterAccountSID=*))
注意：
! 操作符与通配符的结合使用可查找属性未设置为任何值的对象。
摘自：www.microsoft.com
转自: http://www.cnblogs.com/xray2005/archive/2008/05/07/1187504.html
LDAP 查询基本知识
基本 LDAP 语法
•
=（等于）
此 LDAP 参数表明某个属性等于某个值的条件得到满足。例如，如果希望查找“名“属性为“John”的所有对象，可以使用：
(givenName=John)
这会返回“名”属性为“John”的所有对象。圆括号是必需的，以便强调 LDAP 语句的开始和结束。
•
&（逻辑与）
如果具有多个条件并且希望全部条件都得到满足，则可使用此语法。例如，如果希望查找居住在 Dallas 并且“名”为“John”的所有人员，可以使用：
(&(givenName=John)(l=Dallas))
请注意，每个参数都被属于其自己的圆括号括起来。整个 LDAP 语句必须包括在一对主圆括号中。操作符 & 表明，只有每个参数都为真，才会将此筛选条件应用到要查询的对象。
•
!（逻辑非）
此操作符用来排除具有特定属性的对象。假定您需要查找“名”为“John”的对象以外的所有对象。则应使用如下语句：
(!givenName=John)
此语句将查找“名”不为“John”的所有对象。请注意：! 操作符紧邻参数的前面，并且位于参数的圆括号内。由于本语句只有一个参数，因此使用圆括号将其括起以示说明。
•
*（通配符）
可使用通配符表示值可以等于任何值。使用它的情况可能是：您希望查找具有职务头衔的所有对象。为此，可以使用：
(title=*)
这会返回“title”属性包含内容的所有对象。另一个例子是：您知道某个对象的“名”属性的开头两个字母是“Jo”。那么，可以使用如下语法进行查找：
(givenName=Jo*)
这会返回“名”以“Jo”开头的所有对象。
•
以下是 LDAP 语法的高级使用示例：
•
您需要一个筛选条件，用来查找居住在 Dallas 或 Austin，并且名为“John”的所有对象。使用的语法应当是：
(&(givenName=John)(|(l=Dallas)(l=Austin)))
•
您发现应用程序日志中有 9,548 个事件，因此需要查找导致这些日志事件的所有对象。在此情况下，您需要查找所有被禁用的用户 (msExchUserAccountControl=2)，这些用户的 msExchMasterAccountSID 没有值。使用的语法应当是：
(&(msExchUserAccountControl=2)(!msExchMasterAccountSID=*))
注意：
! 操作符与通配符的结合使用可查找属性未设置为任何值的对象。
摘自：www.microsoft.com
Monday, April 20, 2009
Sunday, April 19, 2009
Thursday, April 16, 2009
PHP5+APACHE2.2配置成功案例(WindowsXP)
更多精彩请到 http://www.139ya.com
PHP5+APACHE2.2配置成功案例：
第一、安装并配置APACHE（以我的为例，安装到D:\servers\apache）
apache相关命令: D:\servers\apache\bin
httpd -k install : 注册apache httpd为windows 系统服务 (注意在系统服务中将其设为手动)
httpd -k start : 启动apache
httpd -k restart : 重启动apache
1、安装时默认安装，Network Domain, Server Name 我填写我的计算机名，Administrator's Email Address区域填你的邮件地址
2、安装完后在安装目录下有个conf文件夹，打开httpd.conf文件进行配置
·找到 DocumentRoot ，将其设置为你所要存放php, htm等网页文件的文件夹，如 "D:\servers\apache\htdocs"；
·找到 Directory，将其设置为你所要存放php, htm等网页文件的文件夹，如 "D:\servers\apache\htdocs"；
·找到 DirectoryIndex ，在index.html后添加index.php, index.htm等，以单个空格将其分开；
·重启Apache (httpd -k restart)，
用http://localhost或http://127.0.0.1或http://yourcompanyname测试是否成功。成功的话屏幕会有个It works! (当然在你新的
htdocs目录下要有index.html)
第二、安装配置PHP（解压PHP压缩包到d:\php\）
1、将php.ini-recommended文件重命名为php.ini并将其剪到系统所在目录下(如放在2000/NT的WINNT/system32, XP的Windows目录下!!!),
2、将extension_dir 改为php/ext所在目录，如 "d:\php\ext"；
3、将doc_root 改为第一步中的同样目录，如 "E:\Program Files\Apache Software Foundation\Apache2.2\htdocs"；
4、找到 ;session.save_path = "/tmp" ,将';'去掉,设置你保存session的目录，如session.save_path = "D:/php/session_temp"
5、将php 目录下的libmysql.dll, php_mysql.dll, php_mysqli.dll 拷到XP的Windows目录下!!!
；
5、然后把下面几句前面的分号去掉,以更好支持Mysql and PHPmyadmin
extension=php_mbstring.dll
extension=php_gd2.dll
extension=php_mysql.dll
第三、PHP+APACHE
1、允许Apache将PHP程序作为模块来运行:
打开httpd.conf,添加下面内容(位置任意)：
LoadModule php5_module "d:/php/php5apache2_2.dll"(特别注意这一条，很多地方是调用php5apache2.dll，这样在运行
PHP代码时会提示httpd.exe应用程序错误)
AddType application/x-httpd-php .php
AddType application/x-httpd-php .htm
（.htm, .php为可执行php语言的扩展名，也可加html, php3, php4,甚至txt）
---------------------------------------------------------------------------------------------
（以下两步可以不需要！！！！！！）
2、如果你出于某种原因而需要在CGI模式中运行PHP程序（使用Php.exe），
请将上面这一行变成注释（各行头加#即可），添加下面这些行：
# ScriptAlias /php/ "d:/php/"
# AddType application/x-httpd-php .php
#Action application/x-httpd-php "/php/php-cgi.exe"
3、现在apache 2 支持HTML而不支持PHP,先把下面几句加到d:\apache2\conf\httpd.conf去:
# ScriptAlias /php/ "d:/php/"
# AddType application/x-httpd-php .php
#Action application/x-httpd-php "/php/php-cgi.exe"
---------------------------------------------------------------------------------------------
第四、重起服务 httpd -k restart
1、在d:\PHP里找到php5ts.dll,libmysql.dll将其复制到c:\winnt\system32下(winNT/2000的机器),而winXP/2003是复制到
c:\windows\system32下
2、测试Apache与php是否连接成功：
启动start apache服务或者正在运行的就重新启动restart apache
3、在Web根目录下新建test.php（即E:\Program Files\Apache Software Foundation\Apache2.2\htdocs目下）
4、运行http://localhost/test.php
如果成功，则应该看到一个含有PHP徽标的网页，其中包含大量设置和其他信息
那么恭喜你
PHP5+APACHE2.2配置成功案例：
第一、安装并配置APACHE（以我的为例，安装到D:\servers\apache）
apache相关命令: D:\servers\apache\bin
httpd -k install : 注册apache httpd为windows 系统服务 (注意在系统服务中将其设为手动)
httpd -k start : 启动apache
httpd -k restart : 重启动apache
1、安装时默认安装，Network Domain, Server Name 我填写我的计算机名，Administrator's Email Address区域填你的邮件地址
2、安装完后在安装目录下有个conf文件夹，打开httpd.conf文件进行配置
·找到 DocumentRoot ，将其设置为你所要存放php, htm等网页文件的文件夹，如 "D:\servers\apache\htdocs"；
·找到 Directory，将其设置为你所要存放php, htm等网页文件的文件夹，如 "D:\servers\apache\htdocs"；
·找到 DirectoryIndex ，在index.html后添加index.php, index.htm等，以单个空格将其分开；
·重启Apache (httpd -k restart)，
用http://localhost或http://127.0.0.1或http://yourcompanyname测试是否成功。成功的话屏幕会有个It works! (当然在你新的
htdocs目录下要有index.html)
第二、安装配置PHP（解压PHP压缩包到d:\php\）
1、将php.ini-recommended文件重命名为php.ini并将其剪到系统所在目录下(如放在2000/NT的WINNT/system32, XP的Windows目录下!!!),
2、将extension_dir 改为php/ext所在目录，如 "d:\php\ext"；
3、将doc_root 改为第一步中的同样目录，如 "E:\Program Files\Apache Software Foundation\Apache2.2\htdocs"；
4、找到 ;session.save_path = "/tmp" ,将';'去掉,设置你保存session的目录，如session.save_path = "D:/php/session_temp"
5、将php 目录下的libmysql.dll, php_mysql.dll, php_mysqli.dll 拷到XP的Windows目录下!!!
；
5、然后把下面几句前面的分号去掉,以更好支持Mysql and PHPmyadmin
extension=php_mbstring.dll
extension=php_gd2.dll
extension=php_mysql.dll
第三、PHP+APACHE
1、允许Apache将PHP程序作为模块来运行:
打开httpd.conf,添加下面内容(位置任意)：
LoadModule php5_module "d:/php/php5apache2_2.dll"(特别注意这一条，很多地方是调用php5apache2.dll，这样在运行
PHP代码时会提示httpd.exe应用程序错误)
AddType application/x-httpd-php .php
AddType application/x-httpd-php .htm
（.htm, .php为可执行php语言的扩展名，也可加html, php3, php4,甚至txt）
---------------------------------------------------------------------------------------------
（以下两步可以不需要！！！！！！）
2、如果你出于某种原因而需要在CGI模式中运行PHP程序（使用Php.exe），
请将上面这一行变成注释（各行头加#即可），添加下面这些行：
# ScriptAlias /php/ "d:/php/"
# AddType application/x-httpd-php .php
#Action application/x-httpd-php "/php/php-cgi.exe"
3、现在apache 2 支持HTML而不支持PHP,先把下面几句加到d:\apache2\conf\httpd.conf去:
# ScriptAlias /php/ "d:/php/"
# AddType application/x-httpd-php .php
#Action application/x-httpd-php "/php/php-cgi.exe"
---------------------------------------------------------------------------------------------
第四、重起服务 httpd -k restart
1、在d:\PHP里找到php5ts.dll,libmysql.dll将其复制到c:\winnt\system32下(winNT/2000的机器),而winXP/2003是复制到
c:\windows\system32下
2、测试Apache与php是否连接成功：
启动start apache服务或者正在运行的就重新启动restart apache
3、在Web根目录下新建test.php（即E:\Program Files\Apache Software Foundation\Apache2.2\htdocs目下）
4、运行http://localhost/test.php
如果成功，则应该看到一个含有PHP徽标的网页，其中包含大量设置和其他信息
那么恭喜你
Wednesday, April 15, 2009
tomcat6.0与tomcat5.5 的区别
更多精彩请到 http://www.139ya.com
转自: http://www.javaeye.com/problems/2428
Tomcat6.x在目录上最大的区别就是将 lib 包直接置于 CATALINA_HOME/lib 下，而tomcat 5.x 系列版本是分common/share/server 三个包存放的。再具体解释一下：
CATALINA_HOME/common
在这个目录下的lib目录，存放Tomcat 服务器和所有Web应用都能访问的JAR.
CATALINA_HOME/share
在这个目录下的lib目录，存放所有Web应用都能访问的，但Tomcat 不能访问的JAR。
CATALINA_HOME/server
在这个目录下的lib目录，存放Tomcat 服务器需要的但Web应用不能访问的JAR。
另外该目录下webapps 存放Tomcat 自带的APP-admin和manager两个应用。
common/share/server 三个包中的classes是用来存放class的，就是说你的类库不打成JAR包，而是class文件就直接放在这里。
Tomcat 6.x 在目录结构上就是针对lib包的存放位置做了调整，使应用部署更加方便。另外：
Tomcat 6.x中endorsed 从CATALINA_HOME/common移到根目录下了CATALINA_HOME\endorsed 至于其它没有太大的变化。
另外需要说明的是tomcat 5.x有目录CATALINA_HOME\conf\Catalina\localhost
在Tomcat 6.x中该目录是空的就没给你建，你可以自己建。有好几个朋友问我这个问题了，这里给你提醒一下。
至于xml文件我还没有注意到有什么变化，以后发现了大家在讨论。
转自: http://www.javaeye.com/problems/2428
Tomcat6.x在目录上最大的区别就是将 lib 包直接置于 CATALINA_HOME/lib 下，而tomcat 5.x 系列版本是分common/share/server 三个包存放的。再具体解释一下：
CATALINA_HOME/common
在这个目录下的lib目录，存放Tomcat 服务器和所有Web应用都能访问的JAR.
CATALINA_HOME/share
在这个目录下的lib目录，存放所有Web应用都能访问的，但Tomcat 不能访问的JAR。
CATALINA_HOME/server
在这个目录下的lib目录，存放Tomcat 服务器需要的但Web应用不能访问的JAR。
另外该目录下webapps 存放Tomcat 自带的APP-admin和manager两个应用。
common/share/server 三个包中的classes是用来存放class的，就是说你的类库不打成JAR包，而是class文件就直接放在这里。
Tomcat 6.x 在目录结构上就是针对lib包的存放位置做了调整，使应用部署更加方便。另外：
Tomcat 6.x中endorsed 从CATALINA_HOME/common移到根目录下了CATALINA_HOME\endorsed 至于其它没有太大的变化。
另外需要说明的是tomcat 5.x有目录CATALINA_HOME\conf\Catalina\localhost
在Tomcat 6.x中该目录是空的就没给你建，你可以自己建。有好几个朋友问我这个问题了，这里给你提醒一下。
至于xml文件我还没有注意到有什么变化，以后发现了大家在讨论。
Tomcat 下的9个文件夹的作用
更多精彩请到 http://www.139ya.com
转自: http://phoenix-ghk.javaeye.com/blog/367141
Tomcat 下的9个文件夹的作用
经典Tomcat下有9个目录，分别是bin，common，conf，logs，server，shared，temp，webapps，work 目录，现在对每一目录做介绍。注意，Tomcat6.0以后就没有server和shared文件夹了，没有common文件夹，取而代之的是lib文件夹。
tomcat根目录在tomcat中叫，文章中把tomcat解压后在c：/下。
1./bin：存放各种平台下启动和关闭Tomcat的脚本文件。其中有个档是 catalina.bat，打开这个windos配置文件，在非注释行加入JDK路径，例如：SET JAVA_HOME=C：j2sdk1.4.2_06 保存后，就配置好tomcat环境了。startup.bat是windows下启动tomcat的文件，shutdown.bat是关闭tomcat的文件。
2./common：在common目录下的lib目录，存放Tomcat服务器和所有web应用都能访问的JAR。
3./shared：在shared目录下的lib目录，存放所有web应用能访问的，但Tomcat不能访问的JAR。
4./server：在server/webapps目录中，存放Tomcat自带的两个 APP-admin和manager应用，使用来管理Tomcat-web服务用的。在server/lib目录中，存放tomcat服务器所需要的各，web应用不能访问种jar。
5./work：Tomcat把各种由jsp生成的servlet文件放在这个目录下。work这个文件夹下面的东西建议你去看看就可以明白了 那是JSP文件编译成.java->.classes。
6./temp：临时活页夹，Tomcat运行时候存放临时文件用的。
7./logs：存放Tomcat的日志文件。
8./conf：Tomcat的各种配置文件， tomcat启动的时候需要读取的配置文件:server.xml(tomcat主要配置文件)、web.xml和tomcatat- users.xml、catalina.policy(安全策略文件)等。修改了以后需要重启tomcat才能生效.最重要的是 server.xml；配置tomcat组件的XML文件server.XML其中包括：
I.顶层类元素[Top Level Elements]：位于整个配置文件的顶层， 包括和；
II.连接器类元素[Connectors ]：客户和服务（容器类元素）间的通讯接口。接受客户请求，返回响应结果；；
II.容器类元素[Containers]： 处理客户请求并且生成响应结果，包含3个： ；
IV.嵌套类元素[Nested Components]： 可以加入到容器中的元素，包括： 等
一个包含一个或多个，一个包含唯一一个和一个或多个，多个共享一个；一个包含多个，每个定义一个虚拟主机，包含一个或多个web应用； 元素是代表一个在虚拟主机上运行的Web应用。标签的描述
Please note that for tomcat 5.x， unlike tomcat 4.x， it is NOT recommended to place elements directly in the server.xml file. Instead， put them in the META-INF/context.xml directory of your WAR file or the conf directory as described above.
server.xml配置简介
下面是这个文件中的基本配置信息，更具体的配置信息见tomcat的文档
server:
port 指定一个端口，这个端口负责监听关闭tomcat的请求
shutdown 指定向端口发送的命令字符串
service:
name 指定service的名字
Connector (表示客户端和service之间的连接):
port 指定服务器端要创建的端口号，并在这个断口监听来自客户端的请求
minProcessors 服务器启动时创建的处理请求的线程数
maxProcessors 最大可以创建的处理请求的线程数
enableLookups 如果为true，则可以通过调用request.getRemoteHost()进行DNS查询来得到远程客户端的实际主机名，若为false则不进行DNS查询，而是返回其ip地址
redirectPort 指定服务器正在处理http请求时收到了一个SSL传输请求后重定向的端口号
acceptCount 指定当所有可以使用的处理请求的线程数都被使用时，可以放到处理队列中的请求数，超过这个数的请求将不予处理
connectionTimeout 指定超时的时间数(以毫秒为单位)
Engine (表示指定service中的请求处理机，接收和处理来自Connector的请求)
defaultHost 指定缺省的处理请求的主机名，它至少与其中的一个host元素的name属性值是一样的
Context (表示一个web应用程序，通常为WAR文件，关于WAR的具体信息见servlet规范)
docBase 应用程序的路径或者是WAR文件存放的路径
path 表示此web应用程序的url的前缀，这样请求的url为http://localhost:8080/path/****
reloadable 这个属性非常重要，如果为true，则tomcat会自动检测应用程序的/WEB-INF/lib 和/WEB-INF/classes目录的变化，自动装载新的应用程序，我们可以在不重起tomcat的情况下改变应用程序
host (表示一个虚拟主机):
name 指定主机名
appBase 应用程序基本目录，即存放应用程序的目录
unpackWARs 如果为true，则tomcat会自动将WAR文件解压，否则不解压，直接从WAR文件中运行应用程序
Logger (表示日志，调试和错误信息):
className 指定logger使用的类名，此类必须实现org.apache.catalina.Logger 接口
prefix 指定log文件的前缀
suffix 指定log文件的后缀
timestamp 如果为true，则log文件名中要加入时间，如下例:localhost_log.2001-10-04.txt
Realm (表示存放用户名，密码及role的数据库)
className 指定Realm使用的类名，此类必须实现org.apache.catalina.Realm接口
Valve (功能与Logger差不多，其prefix和suffix属性解释和Logger 中的一样)
className 指定Valve使用的类名，如用org.apache.catalina.valves.AccessLogValve类可以记录应用程序的访问信息
directory 指定log文件存放的位置
pattern 有两个值，common方式记录远程主机名或ip地址，用户名，日期，第一行请求的字符串，HTTP响应代码，发送的字节数。combined方式比common方式记录的值更多
注意：
默认的server.xml中，Realm元素只设置了一个className属性，但此文件中也包含几个通过JDBC连接到数据库进行验证的示例(被注释掉了)，通过Realm元素我们可以实现容器安全管理(Container Managed Security)。
还有一些元素，如Parameter，loader，你可以通过tomcat的文档获取这些元素的信息。
9./webapps： web应用的发布目录，把 java开发的web站点或war文件放入这个目录下就可以通过tomcat服务器访问了。
在绝大多数资料上，都只提到了conf/server.xml以及context下面的 WEB-INF/web.xml，但我发现，有时，在server.xml上面没有配置的内容，tomcat也运行着，后来发现，原来除了这两处配置外，还有一处重要的配置文件，
在TOMCAT_HOME/conf/Catalina/下面(Catalina是server.xml里的engine的名称)，也是一些关键的配置文件，每个主机(server.xml里的Host)，在这里有一个目录，每个主机(Host)里的一个context在该主机目录下有一个对应的xml文件，比如，根目录对应ROOT.xml，其它名为test的context对应test.xml。
TOMCAT_HOME/conf/Catalina/hostname/context1.xml 相当于在server.xml中的Catalina引擎下的hostname主机下配置context1WEB应用。在目录里配置，和在 server.xml里配置效果是一样的，Tomcat自带的admin，自动将所有context转到目录下配置，而不是集中在server.xml。
10、如何新建虚拟目录？
修改 Tomcat安装目录//conf//server.xml ，在下列行前
添加下列行：
表示增加虚拟目录 my，对应物理目录位置c://myjsp//test，若存在c://myjsp//test//hello.jsp，则下列地址可访问：
htpp://localhost:8080/my/hello.jsp
修改server.xml后，需要重新启动tomcat.
转自: http://phoenix-ghk.javaeye.com/blog/367141
Tomcat 下的9个文件夹的作用
经典Tomcat下有9个目录，分别是bin，common，conf，logs，server，shared，temp，webapps，work 目录，现在对每一目录做介绍。注意，Tomcat6.0以后就没有server和shared文件夹了，没有common文件夹，取而代之的是lib文件夹。
tomcat根目录在tomcat中叫
1.
2.
3.
4.
5.
6.
7.
8.
I.顶层类元素[Top Level Elements]：位于整个配置文件的顶层， 包括
II.连接器类元素[Connectors ]：客户和服务（容器类元素）间的通讯接口。接受客户请求，返回响应结果；
II.容器类元素[Containers]： 处理客户请求并且生成响应结果，包含3个：
IV.嵌套类元素[Nested Components]： 可以加入到容器中的元素，包括：
一个
Please note that for tomcat 5.x， unlike tomcat 4.x， it is NOT recommended to place
server.xml配置简介
下面是这个文件中的基本配置信息，更具体的配置信息见tomcat的文档
server:
port 指定一个端口，这个端口负责监听关闭tomcat的请求
shutdown 指定向端口发送的命令字符串
service:
name 指定service的名字
Connector (表示客户端和service之间的连接):
port 指定服务器端要创建的端口号，并在这个断口监听来自客户端的请求
minProcessors 服务器启动时创建的处理请求的线程数
maxProcessors 最大可以创建的处理请求的线程数
enableLookups 如果为true，则可以通过调用request.getRemoteHost()进行DNS查询来得到远程客户端的实际主机名，若为false则不进行DNS查询，而是返回其ip地址
redirectPort 指定服务器正在处理http请求时收到了一个SSL传输请求后重定向的端口号
acceptCount 指定当所有可以使用的处理请求的线程数都被使用时，可以放到处理队列中的请求数，超过这个数的请求将不予处理
connectionTimeout 指定超时的时间数(以毫秒为单位)
Engine (表示指定service中的请求处理机，接收和处理来自Connector的请求)
defaultHost 指定缺省的处理请求的主机名，它至少与其中的一个host元素的name属性值是一样的
Context (表示一个web应用程序，通常为WAR文件，关于WAR的具体信息见servlet规范)
docBase 应用程序的路径或者是WAR文件存放的路径
path 表示此web应用程序的url的前缀，这样请求的url为http://localhost:8080/path/****
reloadable 这个属性非常重要，如果为true，则tomcat会自动检测应用程序的/WEB-INF/lib 和/WEB-INF/classes目录的变化，自动装载新的应用程序，我们可以在不重起tomcat的情况下改变应用程序
host (表示一个虚拟主机):
name 指定主机名
appBase 应用程序基本目录，即存放应用程序的目录
unpackWARs 如果为true，则tomcat会自动将WAR文件解压，否则不解压，直接从WAR文件中运行应用程序
Logger (表示日志，调试和错误信息):
className 指定logger使用的类名，此类必须实现org.apache.catalina.Logger 接口
prefix 指定log文件的前缀
suffix 指定log文件的后缀
timestamp 如果为true，则log文件名中要加入时间，如下例:localhost_log.2001-10-04.txt
Realm (表示存放用户名，密码及role的数据库)
className 指定Realm使用的类名，此类必须实现org.apache.catalina.Realm接口
Valve (功能与Logger差不多，其prefix和suffix属性解释和Logger 中的一样)
className 指定Valve使用的类名，如用org.apache.catalina.valves.AccessLogValve类可以记录应用程序的访问信息
directory 指定log文件存放的位置
pattern 有两个值，common方式记录远程主机名或ip地址，用户名，日期，第一行请求的字符串，HTTP响应代码，发送的字节数。combined方式比common方式记录的值更多
注意：
默认的server.xml中，Realm元素只设置了一个className属性，但此文件中也包含几个通过JDBC连接到数据库进行验证的示例(被注释掉了)，通过Realm元素我们可以实现容器安全管理(Container Managed Security)。
还有一些元素，如Parameter，loader，你可以通过tomcat的文档获取这些元素的信息。
9.
在绝大多数资料上，都只提到了conf/server.xml以及context下面的 WEB-INF/web.xml，但我发现，有时，在server.xml上面没有配置的内容，tomcat也运行着，后来发现，原来除了这两处配置外，还有一处重要的配置文件，
在TOMCAT_HOME/conf/Catalina/下面(Catalina是server.xml里的engine的名称)，也是一些关键的配置文件，每个主机(server.xml里的Host)，在这里有一个目录，每个主机(Host)里的一个context在该主机目录下有一个对应的xml文件，比如，根目录对应ROOT.xml，其它名为test的context对应test.xml。
TOMCAT_HOME/conf/Catalina/hostname/context1.xml 相当于在server.xml中的Catalina引擎下的hostname主机下配置context1WEB应用。在目录里配置，和在 server.xml里配置效果是一样的，Tomcat自带的admin，自动将所有context转到目录下配置，而不是集中在server.xml。
10、如何新建虚拟目录？
修改 Tomcat安装目录//conf//server.xml ，在下列行前
添加下列行：
表示增加虚拟目录 my，对应物理目录位置c://myjsp//test，若存在c://myjsp//test//hello.jsp，则下列地址可访问：
htpp://localhost:8080/my/hello.jsp
修改server.xml后，需要重新启动tomcat.
Tomcat笔记(1)
更多精彩请到 http://www.139ya.com
转自: http://www.javaeye.com/topic/178672
Tomcat笔记(1)
Tomcat启动分析
1 - Tomcat Server的组成部分
1.1 - Server
A Server element represents the entire Catalina servlet container. (Singleton)
1.2 - Service
A Service element represents the combination of one or more Connector components that share a single Engine
Service是这样一个集合：它由一个或者多个Connector组成，以及一个Engine，负责处理所有Connector所获得的客户请求
1.3 - Connector
一个Connector将在某个指定端口上侦听客户请求，并将获得的请求交给Engine来处理，从Engine处获得回应并返回客户
TOMCAT有两个典型的Connector，一个直接侦听来自browser的http请求，一个侦听来自其它WebServer的请求
Coyote Http/1.1 Connector 在端口8080处侦听来自客户browser的http请求
Coyote JK2 Connector 在端口8009处侦听来自其它WebServer(Apache)的servlet/jsp代理请求
1.4 - Engine
The Engine element represents the entire request processing machinery associated with a particular Service
It receives and processes all requests from one or more Connectors
and returns the completed response to the Connector for ultimate transmission back to the client
Engine下可以配置多个虚拟主机Virtual Host，每个虚拟主机都有一个域名
当Engine获得一个请求时，它把该请求匹配到某个Host上，然后把该请求交给该Host来处理
Engine有一个默认虚拟主机，当请求无法匹配到任何一个Host上的时候，将交给该默认Host来处理
1.5 - Host
代表一个Virtual Host，虚拟主机，每个虚拟主机和某个网络域名Domain Name相匹配
每个虚拟主机下都可以部署(deploy)一个或者多个Web App，每个Web App对应于一个Context，有一个Context path
当Host获得一个请求时，将把该请求匹配到某个Context上，然后把该请求交给该Context来处理
匹配的方法是“最长匹配”，所以一个path==""的Context将成为该Host的默认Context
所有无法和其它Context的路径名匹配的请求都将最终和该默认Context匹配
1.6 - Context
一个Context对应于一个Web Application，一个Web Application由一个或者多个Servlet组成
Context在创建的时候将根据配置文件$CATALINA_HOME/conf/web.xml和$WEBAPP_HOME/WEB-INF/web.xml载入Servlet类
当Context获得请求时，将在自己的映射表(mapping table)中寻找相匹配的Servlet类
如果找到，则执行该类，获得请求的回应，并返回
2 - Tomcat Server的结构图
3 - 配置文件$CATALINA_HOME/conf/server.xml的说明
该文件描述了如何启动Tomcat Server
... ... ... ...
minProcessors="5" maxProcessors="75" acceptCount="100"
enableLookups="true"
redirectPort="8443"
debug="0"
connectionTimeout="20000"
useURIValidationHack="false"
disableUploadTimeout="true" />
4 - Context的部署配置文件web.xml的说明
一个Context对应于一个Web App，每个Web App是由一个或者多个servlet组成的
当一个Web App被初始化的时候，它将用自己的ClassLoader对象载入“部署配置文件web.xml”中定义的每个servlet类
它首先载入在$CATALINA_HOME/conf/web.xml中部署的servlet类
然后载入在自己的Web App根目录下的WEB-INF/web.xml中部署的servlet类
web.xml文件有两部分：servlet类定义和servlet映射定义
每个被载入的servlet类都有一个名字，且被填入该Context的映射表(mapping table)中，和某种URL PATTERN对应
当该Context获得请求时，将查询mapping table，找到被请求的servlet，并执行以获得请求回应
分析一下所有的Context共享的web.xml文件，在其中定义的servlet被所有的Web App载入
default
org.apache.catalina.servlets.DefaultServlet
debug
0
listings
true
1
invoker
org.apache.catalina.servlets.InvokerServlet
debug
0
2
jsp
org.apache.jasper.servlet.JspServlet
logVerbosityLevel
WARNING
3
default
/
invoker
/servlet/*
jsp
*.jsp
... ... ... ...
5 - Tomcat Server处理一个http请求的过程
假设来自客户的请求为：
http://localhost:8080/wsota/wsota_index.jsp
1) 请求被发送到本机端口8080，被在那里侦听的Coyote HTTP/1.1 Connector获得
2) Connector把该请求交给它所在的Service的Engine来处理，并等待来自Engine的回应
3) Engine获得请求localhost/wsota/wsota_index.jsp，匹配它所拥有的所有虚拟主机Host
4) Engine匹配到名为localhost的Host（即使匹配不到也把请求交给该Host处理，因为该Host被定义为该Engine的默认主机）
5) localhost Host获得请求/wsota/wsota_index.jsp，匹配它所拥有的所有Context
6) Host匹配到路径为/wsota的Context（如果匹配不到就把该请求交给路径名为""的Context去处理）
7) path="/wsota"的Context获得请求/wsota_index.jsp，在它的mapping table中寻找对应的servlet
8) Context匹配到URL PATTERN为*.jsp的servlet，对应于JspServlet类
9) 构造HttpServletRequest对象和HttpServletResponse对象，作为参数调用JspServlet的doGet或doPost方法
10)Context把执行完了之后的HttpServletResponse对象返回给Host
11)Host把HttpServletResponse对象返回给Engine
12)Engine把HttpServletResponse对象返回给Connector
13)Connector把HttpServletResponse对象返回给客户browser
一、Tomcat背景
自从JSP发布之后，推出了各式各样的JSP引擎。Apache Group在完成GNUJSP1.0的开发以后，开始考虑在SUN的JSWDK基础上开发一个可以直接提供Web服务的JSP服务器，当然同时也支持 Servlet, 这样Tomcat就诞生了。Tomcat是jakarta项目中的一个重要的子项目，其被JavaWorld杂志的编辑选为2001年度最具创新的 java产品，同时它又是sun公司官方推荐的servlet和jsp容器，因此其越来越多的受到软件公司和开发人员的喜爱。servlet和jsp的最新规范都可以在tomcat的新版本中得到实现。其次，Tomcat是完全免费的软件，任何人都可以从互联网上自由地下载。Tomcat与Apache的组合相当完美。
二、Tomcat目录
tomcat
|---bin Tomcat：存放启动和关闭tomcat脚本；
|---conf Tomcat：存放不同的配置文件（server.xml和web.xml）；
|---doc：存放Tomcat文档；
|---lib/japser/common：存放Tomcat运行需要的库文件（JARS）；
|---logs：存放Tomcat执行时的LOG文件；
|---src：存放Tomcat的源代码；
|---webapps：Tomcat的主要Web发布目录（包括应用程序示例）；
|---work：存放jsp编译后产生的class文件；
三、Tomcat类加载
Bootstrap($JAVA_HOME/jre/lib/ext/*.jar)
System($CLASSPATH/*.class和指定的jar)
Common($CATALINA_HOME/common 下的classes,lib,endores三个子目录)
Catalina ($CATALINA_HOME/server/下的classes和lib目录仅对Tomcat可见)
&Shared($CATALINA_HOME/shared/下的classes和lib目录以及$CATALINA_HOME /lib目录)仅对Web应用程序可见,对Tomcat不可见WebApp($WEBAPP/Web-INF/*仅对该WEB应用可见classes /*.class lib/*.jar)
加载类和资源的顺序为：
1、/Web-INF/classes
2、/Web-INF/lib/*.jar
3、Bootstrap
4、System
5、$CATALINA_HOME/common/classes
6、$CATALINA_HOME/common/endores/*.jar
7、$CATALINA_HOME/common/lib/*.jar
8、$CATALINA_HOME/shared/classes
9、$CATALINA_HOME/shared/lib/*.jar
四、server.xml配置简介：
下面讲述这个文件中的基本配置信息，更具体的配置信息请参考tomcat的文档：
server:
1、port 指定一个端口，这个端口负责监听关闭tomcat的请求
2、shutdown 指定向端口发送的命令字符串
service:
1、name 指定service的名字
Connector (表示客户端和service之间的连接)：
1、port 指定服务器端要创建的端口号，并在这个断口监听来自客户端的请求
2、minProcessors 服务器启动时创建的处理请求的线程数
3、maxProcessors 最大可以创建的处理请求的线程数
4、enableLookups 如果为true，则可以通过调用request.getRemoteHost()进行DNS查
询来得到远程客户端的实际主机名，若为false则不进行DNS查询，而是返回其ip
地址
5、redirectPort 指定服务器正在处理http请求时收到了一个SSL传输请求后重定向的
端口号
6、acceptCount 指定当所有可以使用的处理请求的线程数都被使用时，可以放到处理
队列中的请求数，超过这个数的请求将不予处理
7、connectionTimeout 指定超时的时间数(以毫秒为单位)
Engine (表示指定service中的请求处理机，接收和处理来自Connector的请求)：
1、defaultHost 指定缺省的处理请求的主机名，它至少与其中的一个host元素的name
属性值是一样的
Context (表示一个web应用程序)：
1、docBase 应用程序的路径或者是WAR文件存放的路径
2、path 表示此web应用程序的url的前缀，这样请求的url为
http://localhost:8080/path/****
3、reloadable 这个属性非常重要，如果为true，则tomcat会自动检测应用程序的
/WEB-INF/lib 和/WEB-INF/classes目录的变化，自动装载新的应用程序，我们可
以在不重起tomcat的情况下改变应用程序
host (表示一个虚拟主机)：
1、name 指定主机名
2、appBase 应用程序基本目录，即存放应用程序的目录
3、unpackWARs 如果为true，则tomcat会自动将WAR文件解压，否则不解压，直接
从WAR文件中运行应用程序
Logger (表示日志，调试和错误信息)：
1、className 指定logger使用的类名，此类必须实现org.apache.catalina.Logger 接口
2、prefix 指定log文件的前缀
3、suffix 指定log文件的后缀
4、timestamp 如果为true，则log文件名中要加入时间，如下
例:localhost_log.2001-10-04.txt
Realm (表示存放用户名，密码及role的数据库)：
1、className 指定Realm使用的类名，此类必须实现org.apache.catalina.Realm接口
Valve (功能与Logger差不多，其prefix和suffix属性解释和Logger 中的一样)：
1、className 指定Valve使用的类名，如用org.apache.catalina.valves.AccessLogValve
类可以记录应用程序的访问信息
directory（指定log文件存放的位置）：
1、pattern 有两个值，common方式记录远程主机名或ip地址，用户名，日期，第一行
请求的字符串，HTTP响应代码，发送的字节数。combined方式比common方式记
录的值更多
五、web.xml配置简介：
1、默认(欢迎)文件的设置
在tomcat4\conf\web.xml中，与IIS中的默认文件意思相同。
index.html
index.htm
index.jsp
2、报错文件的设置
404
/notFileFound.jsp
java.lang.NullPointerException
/null.jsp
如果某文件资源没有找到，服务器要报404错误，按上述配置则会调用\webapps\ROOT\notFileFound.jsp。
如果执行的某个JSP文件产生NullPointException ，则会调用\webapps\ROOT\null.jsp
3、会话超时的设置
设置session 的过期时间，单位是分钟；
30
4、过滤器的设置
FilterSource
project4. FilterSource
FilterSource
/WwwServlet
(/haha/* )
过滤：
1) 身份验证的过滤Authentication Filters
2) 日志和审核的过滤Logging and Auditing Filters
3) 图片转化的过滤Image conversion Filters
4) 数据压缩的过滤Data compression Filters
5) 加密过滤Encryption Filters
6) Tokenizing Filters
7) 资源访问事件触发的过滤Filters that trigger resource access events XSL/T 过滤XSL/T filters
9) 内容类型的过滤Mime-type chain Filter 注意监听器的顺序，如：先安全过滤，然后资源，
然后内容类型等，这个顺序可以自己定。
六、管理
1、用户配置
在进行具体Tomcat管理之前，先给tomcat添加一个用户，使这个用户有权限来进行管理。
打开conf目录下的tomcat-users.xml文件，在相应的位置添加下面一行：
然后重起tomcat，在浏览器中输入http://localhost:8080/manager/，会弹出对话框，输入上面的用户
名和密码即可。
2、应用程序列表
在浏览器中输入http://localhost:8080/manager/list，浏览器将会显示如下的信息：
OK - Listed applications for virtual host localhost
/ex:running:1
/examples:running:1
/webdav:running:0
/tomcat-docs:running:0
/manager:running:0
/:running:0
上面显示的信息分别为：应用程序的路径、当前状态、连接这个程序的session数
3、重新装载应用程序
在浏览器中输入 http://localhost:8080/manager/reload?path=/examples，浏览器显示如下：
OK - Reloaded application at context path /examples
这表示example应用程序装载成功，如果我们将server.xml的Context元素的reloadable属性设为true，则没必要利用这种方式重新装载应用程序，因为tomcat会自动装载。
4、显示session信息
在浏览器中输入http://localhost:8080/manager/sessions?path=/examples，浏览器显示如下：
OK - Session information for application at context path /examples Default maximum session inactive
interval 30 minutes
5、启动和关闭应用程序
在浏览器中输入http://localhost:8080/manager/start?path=/examples和
http://localhost:8080/manager/stop?path=/examples分别启动和关闭examples应用程序。
转自: http://www.javaeye.com/topic/178672
Tomcat笔记(1)
Tomcat启动分析
1 - Tomcat Server的组成部分
1.1 - Server
A Server element represents the entire Catalina servlet container. (Singleton)
1.2 - Service
A Service element represents the combination of one or more Connector components that share a single Engine
Service是这样一个集合：它由一个或者多个Connector组成，以及一个Engine，负责处理所有Connector所获得的客户请求
1.3 - Connector
一个Connector将在某个指定端口上侦听客户请求，并将获得的请求交给Engine来处理，从Engine处获得回应并返回客户
TOMCAT有两个典型的Connector，一个直接侦听来自browser的http请求，一个侦听来自其它WebServer的请求
Coyote Http/1.1 Connector 在端口8080处侦听来自客户browser的http请求
Coyote JK2 Connector 在端口8009处侦听来自其它WebServer(Apache)的servlet/jsp代理请求
1.4 - Engine
The Engine element represents the entire request processing machinery associated with a particular Service
It receives and processes all requests from one or more Connectors
and returns the completed response to the Connector for ultimate transmission back to the client
Engine下可以配置多个虚拟主机Virtual Host，每个虚拟主机都有一个域名
当Engine获得一个请求时，它把该请求匹配到某个Host上，然后把该请求交给该Host来处理
Engine有一个默认虚拟主机，当请求无法匹配到任何一个Host上的时候，将交给该默认Host来处理
1.5 - Host
代表一个Virtual Host，虚拟主机，每个虚拟主机和某个网络域名Domain Name相匹配
每个虚拟主机下都可以部署(deploy)一个或者多个Web App，每个Web App对应于一个Context，有一个Context path
当Host获得一个请求时，将把该请求匹配到某个Context上，然后把该请求交给该Context来处理
匹配的方法是“最长匹配”，所以一个path==""的Context将成为该Host的默认Context
所有无法和其它Context的路径名匹配的请求都将最终和该默认Context匹配
1.6 - Context
一个Context对应于一个Web Application，一个Web Application由一个或者多个Servlet组成
Context在创建的时候将根据配置文件$CATALINA_HOME/conf/web.xml和$WEBAPP_HOME/WEB-INF/web.xml载入Servlet类
当Context获得请求时，将在自己的映射表(mapping table)中寻找相匹配的Servlet类
如果找到，则执行该类，获得请求的回应，并返回
2 - Tomcat Server的结构图
3 - 配置文件$CATALINA_HOME/conf/server.xml的说明
该文件描述了如何启动Tomcat Server
... ... ... ...
minProcessors="5" maxProcessors="75" acceptCount="100"
enableLookups="true"
redirectPort="8443"
debug="0"
connectionTimeout="20000"
useURIValidationHack="false"
disableUploadTimeout="true" />
4 - Context的部署配置文件web.xml的说明
一个Context对应于一个Web App，每个Web App是由一个或者多个servlet组成的
当一个Web App被初始化的时候，它将用自己的ClassLoader对象载入“部署配置文件web.xml”中定义的每个servlet类
它首先载入在$CATALINA_HOME/conf/web.xml中部署的servlet类
然后载入在自己的Web App根目录下的WEB-INF/web.xml中部署的servlet类
web.xml文件有两部分：servlet类定义和servlet映射定义
每个被载入的servlet类都有一个名字，且被填入该Context的映射表(mapping table)中，和某种URL PATTERN对应
当该Context获得请求时，将查询mapping table，找到被请求的servlet，并执行以获得请求回应
分析一下所有的Context共享的web.xml文件，在其中定义的servlet被所有的Web App载入
org.apache.catalina.servlets.DefaultServlet
org.apache.catalina.servlets.InvokerServlet
... ... ... ...
5 - Tomcat Server处理一个http请求的过程
假设来自客户的请求为：
http://localhost:8080/wsota/wsota_index.jsp
1) 请求被发送到本机端口8080，被在那里侦听的Coyote HTTP/1.1 Connector获得
2) Connector把该请求交给它所在的Service的Engine来处理，并等待来自Engine的回应
3) Engine获得请求localhost/wsota/wsota_index.jsp，匹配它所拥有的所有虚拟主机Host
4) Engine匹配到名为localhost的Host（即使匹配不到也把请求交给该Host处理，因为该Host被定义为该Engine的默认主机）
5) localhost Host获得请求/wsota/wsota_index.jsp，匹配它所拥有的所有Context
6) Host匹配到路径为/wsota的Context（如果匹配不到就把该请求交给路径名为""的Context去处理）
7) path="/wsota"的Context获得请求/wsota_index.jsp，在它的mapping table中寻找对应的servlet
8) Context匹配到URL PATTERN为*.jsp的servlet，对应于JspServlet类
9) 构造HttpServletRequest对象和HttpServletResponse对象，作为参数调用JspServlet的doGet或doPost方法
10)Context把执行完了之后的HttpServletResponse对象返回给Host
11)Host把HttpServletResponse对象返回给Engine
12)Engine把HttpServletResponse对象返回给Connector
13)Connector把HttpServletResponse对象返回给客户browser
一、Tomcat背景
自从JSP发布之后，推出了各式各样的JSP引擎。Apache Group在完成GNUJSP1.0的开发以后，开始考虑在SUN的JSWDK基础上开发一个可以直接提供Web服务的JSP服务器，当然同时也支持 Servlet, 这样Tomcat就诞生了。Tomcat是jakarta项目中的一个重要的子项目，其被JavaWorld杂志的编辑选为2001年度最具创新的 java产品，同时它又是sun公司官方推荐的servlet和jsp容器，因此其越来越多的受到软件公司和开发人员的喜爱。servlet和jsp的最新规范都可以在tomcat的新版本中得到实现。其次，Tomcat是完全免费的软件，任何人都可以从互联网上自由地下载。Tomcat与Apache的组合相当完美。
二、Tomcat目录
tomcat
|---bin Tomcat：存放启动和关闭tomcat脚本；
|---conf Tomcat：存放不同的配置文件（server.xml和web.xml）；
|---doc：存放Tomcat文档；
|---lib/japser/common：存放Tomcat运行需要的库文件（JARS）；
|---logs：存放Tomcat执行时的LOG文件；
|---src：存放Tomcat的源代码；
|---webapps：Tomcat的主要Web发布目录（包括应用程序示例）；
|---work：存放jsp编译后产生的class文件；
三、Tomcat类加载
Bootstrap($JAVA_HOME/jre/lib/ext/*.jar)
System($CLASSPATH/*.class和指定的jar)
Common($CATALINA_HOME/common 下的classes,lib,endores三个子目录)
Catalina ($CATALINA_HOME/server/下的classes和lib目录仅对Tomcat可见)
&Shared($CATALINA_HOME/shared/下的classes和lib目录以及$CATALINA_HOME /lib目录)仅对Web应用程序可见,对Tomcat不可见WebApp($WEBAPP/Web-INF/*仅对该WEB应用可见classes /*.class lib/*.jar)
加载类和资源的顺序为：
1、/Web-INF/classes
2、/Web-INF/lib/*.jar
3、Bootstrap
4、System
5、$CATALINA_HOME/common/classes
6、$CATALINA_HOME/common/endores/*.jar
7、$CATALINA_HOME/common/lib/*.jar
8、$CATALINA_HOME/shared/classes
9、$CATALINA_HOME/shared/lib/*.jar
四、server.xml配置简介：
下面讲述这个文件中的基本配置信息，更具体的配置信息请参考tomcat的文档：
server:
1、port 指定一个端口，这个端口负责监听关闭tomcat的请求
2、shutdown 指定向端口发送的命令字符串
service:
1、name 指定service的名字
Connector (表示客户端和service之间的连接)：
1、port 指定服务器端要创建的端口号，并在这个断口监听来自客户端的请求
2、minProcessors 服务器启动时创建的处理请求的线程数
3、maxProcessors 最大可以创建的处理请求的线程数
4、enableLookups 如果为true，则可以通过调用request.getRemoteHost()进行DNS查
询来得到远程客户端的实际主机名，若为false则不进行DNS查询，而是返回其ip
地址
5、redirectPort 指定服务器正在处理http请求时收到了一个SSL传输请求后重定向的
端口号
6、acceptCount 指定当所有可以使用的处理请求的线程数都被使用时，可以放到处理
队列中的请求数，超过这个数的请求将不予处理
7、connectionTimeout 指定超时的时间数(以毫秒为单位)
Engine (表示指定service中的请求处理机，接收和处理来自Connector的请求)：
1、defaultHost 指定缺省的处理请求的主机名，它至少与其中的一个host元素的name
属性值是一样的
Context (表示一个web应用程序)：
1、docBase 应用程序的路径或者是WAR文件存放的路径
2、path 表示此web应用程序的url的前缀，这样请求的url为
http://localhost:8080/path/****
3、reloadable 这个属性非常重要，如果为true，则tomcat会自动检测应用程序的
/WEB-INF/lib 和/WEB-INF/classes目录的变化，自动装载新的应用程序，我们可
以在不重起tomcat的情况下改变应用程序
host (表示一个虚拟主机)：
1、name 指定主机名
2、appBase 应用程序基本目录，即存放应用程序的目录
3、unpackWARs 如果为true，则tomcat会自动将WAR文件解压，否则不解压，直接
从WAR文件中运行应用程序
Logger (表示日志，调试和错误信息)：
1、className 指定logger使用的类名，此类必须实现org.apache.catalina.Logger 接口
2、prefix 指定log文件的前缀
3、suffix 指定log文件的后缀
4、timestamp 如果为true，则log文件名中要加入时间，如下
例:localhost_log.2001-10-04.txt
Realm (表示存放用户名，密码及role的数据库)：
1、className 指定Realm使用的类名，此类必须实现org.apache.catalina.Realm接口
Valve (功能与Logger差不多，其prefix和suffix属性解释和Logger 中的一样)：
1、className 指定Valve使用的类名，如用org.apache.catalina.valves.AccessLogValve
类可以记录应用程序的访问信息
directory（指定log文件存放的位置）：
1、pattern 有两个值，common方式记录远程主机名或ip地址，用户名，日期，第一行
请求的字符串，HTTP响应代码，发送的字节数。combined方式比common方式记
录的值更多
五、web.xml配置简介：
1、默认(欢迎)文件的设置
在tomcat4\conf\web.xml中，
2、报错文件的设置
如果某文件资源没有找到，服务器要报404错误，按上述配置则会调用\webapps\ROOT\notFileFound.jsp。
如果执行的某个JSP文件产生NullPointException ，则会调用\webapps\ROOT\null.jsp
3、会话超时的设置
设置session 的过期时间，单位是分钟；
4、过滤器的设置
(
过滤：
1) 身份验证的过滤Authentication Filters
2) 日志和审核的过滤Logging and Auditing Filters
3) 图片转化的过滤Image conversion Filters
4) 数据压缩的过滤Data compression Filters
5) 加密过滤Encryption Filters
6) Tokenizing Filters
7) 资源访问事件触发的过滤Filters that trigger resource access events XSL/T 过滤XSL/T filters
9) 内容类型的过滤Mime-type chain Filter 注意监听器的顺序，如：先安全过滤，然后资源，
然后内容类型等，这个顺序可以自己定。
六、管理
1、用户配置
在进行具体Tomcat管理之前，先给tomcat添加一个用户，使这个用户有权限来进行管理。
打开conf目录下的tomcat-users.xml文件，在相应的位置添加下面一行：
然后重起tomcat，在浏览器中输入http://localhost:8080/manager/，会弹出对话框，输入上面的用户
名和密码即可。
2、应用程序列表
在浏览器中输入http://localhost:8080/manager/list，浏览器将会显示如下的信息：
OK - Listed applications for virtual host localhost
/ex:running:1
/examples:running:1
/webdav:running:0
/tomcat-docs:running:0
/manager:running:0
/:running:0
上面显示的信息分别为：应用程序的路径、当前状态、连接这个程序的session数
3、重新装载应用程序
在浏览器中输入 http://localhost:8080/manager/reload?path=/examples，浏览器显示如下：
OK - Reloaded application at context path /examples
这表示example应用程序装载成功，如果我们将server.xml的Context元素的reloadable属性设为true，则没必要利用这种方式重新装载应用程序，因为tomcat会自动装载。
4、显示session信息
在浏览器中输入http://localhost:8080/manager/sessions?path=/examples，浏览器显示如下：
OK - Session information for application at context path /examples Default maximum session inactive
interval 30 minutes
5、启动和关闭应用程序
在浏览器中输入http://localhost:8080/manager/start?path=/examples和
http://localhost:8080/manager/stop?path=/examples分别启动和关闭examples应用程序。
Tuesday, April 14, 2009
Alfresco Web Script Pages
更多精彩请到 http://www.139ya.com
http://wiki.alfresco.com/wiki/Web_Scripts
http://wiki.alfresco.com/wiki/Web_Scripts_Examples
http://wiki.alfresco.com/wiki/Web_Scripts_Hello_World_Quick_Start
Listing_Available_Web_Scripts : http://wiki.alfresco.com/wiki/Web_Scripts#Listing_Available_Web_Scripts
Deciding_Where_to_place_Web_Script_Implementation : http://wiki.alfresco.com/wiki/Web_Scripts#Deciding_Where_to_place_Web_Script_Implementation
WebScripts Configuration : http://wiki.alfresco.com/wiki/3.0_Web_Scripts_Framework#Configuration
Java-backed_Web_Scripts_Samples : http://wiki.alfresco.com/wiki/Java-backed_Web_Scripts_Samples
http://wiki.alfresco.com/wiki/Web_Scripts_Examples
http://www.optaros.com/blogs/running-alfresco-web-scripts-liferay-portlets
https://www.liferay.com/zh_CN/web/guest/community/forums/-/message_boards/category/243732;jsessionid=77BA415F3FF1DD797023CECF4D9459E5
https://www.liferay.com/zh_CN/web/guest/community/home
http://wiki.alfresco.com/wiki/Web_Scripts
http://wiki.alfresco.com/wiki/Web_Scripts_Examples
http://wiki.alfresco.com/wiki/Web_Scripts_Hello_World_Quick_Start
Listing_Available_Web_Scripts : http://wiki.alfresco.com/wiki/Web_Scripts#Listing_Available_Web_Scripts
Deciding_Where_to_place_Web_Script_Implementation : http://wiki.alfresco.com/wiki/Web_Scripts#Deciding_Where_to_place_Web_Script_Implementation
WebScripts Configuration : http://wiki.alfresco.com/wiki/3.0_Web_Scripts_Framework#Configuration
Java-backed_Web_Scripts_Samples : http://wiki.alfresco.com/wiki/Java-backed_Web_Scripts_Samples
http://wiki.alfresco.com/wiki/Web_Scripts_Examples
http://www.optaros.com/blogs/running-alfresco-web-scripts-liferay-portlets
https://www.liferay.com/zh_CN/web/guest/community/forums/-/message_boards/category/243732;jsessionid=77BA415F3FF1DD797023CECF4D9459E5
https://www.liferay.com/zh_CN/web/guest/community/home
Alfresco Launches Rapid Web Site Development Tool
更多精彩请到 http://www.139ya.com
http://www.alfresco.com/media/releases/2009/01/web-studio-labs3/
Alfresco WCM - an enterprise-class content creation platform and repository;
Alfresco Surf - a web application and site assembly framework for developers; and,
Alfresco Web Studio - a graphical design and site assembly tool for business users.
http://www.alfresco.com/media/releases/2009/01/web-studio-labs3/
Alfresco WCM - an enterprise-class content creation platform and repository;
Alfresco Surf - a web application and site assembly framework for developers; and,
Alfresco Web Studio - a graphical design and site assembly tool for business users.
Alfresco Trouble Shooting
更多精彩请到 http://www.139ya.com
Installation:
1. Linux Installation Troubleshooting: http://wiki.alfresco.com/wiki/Linux_Installation_Troubleshooting
Out of Memory Errors
These can really stuff up the bootstrapping process. If you have not allocated enough memory to the JVM then the bootstrapping process will abort unpredictably.
You can diagnose this by grepping catalina.out for
java.lang.OutOfMemoryError: Java heap space
To fix this make sure the JVM is passed a command line argument of something like -Xmx1024m
Damaged Installation after Out of Memory Errors
Once you have fixed the OOM errors Alfresco may refuse to install or start if there is data left lying around after an aborted install.
For example the following errors may be found in catalina.out:
00:13:42,211 ERROR [repo.admin.ConfigurationChecker] CONTENT INTEGRITY ERROR: System content not found in content store.
00:13:42,211 ERROR [repo.admin.ConfigurationChecker] Ensure that the 'dir.root' property is pointing to the correct data location.
00:13:42,224 ERROR [web.context.ContextLoader] Context initialization failed
org.alfresco.error.AlfrescoRuntimeException: Ensure that the 'dir.root' property is pointing to the correct data location.
To clean up Alfresco try the following.
1. stop tomcat
2. delete everything in dir.root. This is where Alfresco stores content, indexes, etc. Its defined in custom-repository.properties
3. drop the database. Log into mysql as root or the alfresco user (defined by 'db.username' in custom-repository.properties)
mysql> drop database alfresco;
mysql> create database alfresco;
4. set the following value in custom-repository.properties to make Alfresco recreate the indexes
index.recovery.mode=FULL
5. start tomcat and monitor the logs.
File Errors
If you are logged in as root and have followed the instructions for configuring Alfresco then you will have edited files and they will be owned by root. Alfresco may not be able to access them. This will give unpredictable errors in catalina.out that Alfresco cannot read files, or create them or whatever.
To fix this try chown-ing everything (once again)
chown -R alfresco:alfresco /opt/alfresco/tomcat
chown -R alfresco:alfresco /var/lib/alfresco
Note that the username and file locations may be different depending on which set of instructions you followed.
Installation:
1. Linux Installation Troubleshooting: http://wiki.alfresco.com/wiki/Linux_Installation_Troubleshooting
Out of Memory Errors
These can really stuff up the bootstrapping process. If you have not allocated enough memory to the JVM then the bootstrapping process will abort unpredictably.
You can diagnose this by grepping catalina.out for
java.lang.OutOfMemoryError: Java heap space
To fix this make sure the JVM is passed a command line argument of something like -Xmx1024m
Damaged Installation after Out of Memory Errors
Once you have fixed the OOM errors Alfresco may refuse to install or start if there is data left lying around after an aborted install.
For example the following errors may be found in catalina.out:
00:13:42,211 ERROR [repo.admin.ConfigurationChecker] CONTENT INTEGRITY ERROR: System content not found in content store.
00:13:42,211 ERROR [repo.admin.ConfigurationChecker] Ensure that the 'dir.root' property is pointing to the correct data location.
00:13:42,224 ERROR [web.context.ContextLoader] Context initialization failed
org.alfresco.error.AlfrescoRuntimeException: Ensure that the 'dir.root' property is pointing to the correct data location.
To clean up Alfresco try the following.
1. stop tomcat
2. delete everything in dir.root. This is where Alfresco stores content, indexes, etc. Its defined in custom-repository.properties
3. drop the database. Log into mysql as root or the alfresco user (defined by 'db.username' in custom-repository.properties)
mysql> drop database alfresco;
mysql> create database alfresco;
4. set the following value in custom-repository.properties to make Alfresco recreate the indexes
index.recovery.mode=FULL
5. start tomcat and monitor the logs.
File Errors
If you are logged in as root and have followed the instructions for configuring Alfresco then you will have edited files and they will be owned by root. Alfresco may not be able to access them. This will give unpredictable errors in catalina.out that Alfresco cannot read files, or create them or whatever.
To fix this try chown-ing everything (once again)
chown -R alfresco:alfresco /opt/alfresco/tomcat
chown -R alfresco:alfresco /var/lib/alfresco
Note that the username and file locations may be different depending on which set of instructions you followed.
Subscribe to:
Posts (Atom)
Posts
