BlogJava-天行健-随笔分类-JAVA

SWT应用程序的组成

重归本垒（Bing） — Tue, 14 Jun 2011 06:33:00 GMT

一个SWT应用程序的基本组成部分为显示界面（Display）、命令界面（Shell，使命令进入并使运行初始化）和窗口部件（Widgets）。Display负责管理事件循环和控制UI线程和其他线程之间的通讯。Shell是应用程序中被操作系统窗口管理器管理的窗口。每个SWT应用程序至少需要一个Display和大于等于1个的Shell实例。

图1：从不同的角度看SWT应用程序

　　图1从不同的角度展示了SWT应用程序。左侧的图是一个简化的UI对象的继承图。中间的图展示了UI对象的容器结构（containment structure）。右侧的图则是创建后的UI外观。

　　如果一个应用程序使用了多个线程，那么每个线程都使用的是Display对象分配给它自己的实例。程序员可以使用静态方法Display.getCurent()来得到Display对象的当前活动的实例。

　　Shell用于在特定的操作系统中表现窗口。Shell可以最大化、最小化或正常化。Shell有两种类型。第1种是高层shell，它是Display的子窗口，同时它也是一个主窗口。第2类是对话shell，这种shell要依赖于其他的shell窗口存在。shell窗口最终成为上述那种类型，要看在创建shell时传递给shell构造函数的是什么风格位（style bits）。一个shell的默认值是DialogShell。也就是说，如果不带参数，那默认就是一个对话shell。而如果给参数赋予了一个Display对象，则该shell将是一个高层shell。

　　一些窗口部件的属性必须在创建它们的初期就要被设置。这些窗口部件的属性就是前面所说的风格位（style bits）。在SWT的类中，风格位被定义为常数。例如，Button button = new Button( shell, )。可以使用或（OR）操作符“|”来设置多个风格位。例如，如果想设置一个带边界的压下按钮，需要传递SWT.PUSH | SWT.BORDER作为风格位参数。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/bnlovebn/archive/2011/06/14/6543693.aspx

重归本垒（Bing） 2011-06-14 14:33 发表评论

关于Myeclipse configuration center中software中的personal sites中添加的插件无法删除的解决

重归本垒（Bing） — Tue, 14 Jun 2011 03:32:00 GMT

找到AppData\Local\Genuitec\Common\configuration\com.genuitec.pulse2.client.common.provisioning中的文件rmb-2042360.latest.snapshot，在文件rmb-2042360.latest.snapshot中找到你要删除的插件名。把这行删除即可。

重归本垒（Bing） 2011-06-14 11:32 发表评论

APPARENT DEADLOCK!!! Creating emergency threads for unassigned pending tasks

重归本垒（Bing） — Sun, 12 Jun 2011 05:51:00 GMT

最近orcale数据只有一台可以服务，导致hibernate 连接数据库每个13分钟就会报“APPARENT DEADLOCK!!! Creating emergency threads for unassigned pending tasks”的错误.
原因是 hibernate 使用c3p0连接orcale数据后不会释放， c3p0的最大连接数为100，但显然c3p0有Bug，导致数据库连接池不够用，导致进程锁死。
后换Proxool后，观察正常。

下面转引其它网友文章说明c3p0 、 Proxool、 dbcp 的区别

1
2<property name="connection.driver_class">com.mysql.jdbc.Driverproperty> <property name="connection.url">jdbc:mysql://localhost:3306/struts?useUnicode=true&characterEncoding=GBKproperty>
3<property name="connection.username">rootproperty>

上面的一段配置，在c3p0和dbcp中，都是必需的，因为hibernate会根据上述的配置来生成connections，再交给c3p0或dbcp管理.

1 C3P0

只需在hibernate.cfg.xml中加入

1<property name="c3p0.min_size">5property>
2<property name="c3p0.max_size">30property>
3<property name="c3p0.time_out">1800property>
4<property name="c3p0.max_statement">50property>
5

还有在classespath中加入c3p0-0.8.4.5.jar

2 dbcp

在hibernate.cfg.xml中加入

1<property name="dbcp.maxActive">100property>
2<property name="dbcp.whenExhaustedAction">1property>
3<property name="dbcp.maxWait">60000property>
4<property name="dbcp.maxIdle">10property>
5
6<property name="dbcp.ps.maxActive">100property>
7<property name="dbcp.ps.whenExhaustedAction">1property>
8<property name="dbcp.ps.maxWait">60000property>
9<property name="dbcp.ps.maxIdle">10property>
10

还有在classespath中加入commons-pool-1.2.jar 和commons-dbcp-1.2.1.jar.

3 proxool

由于数据库connection在较长时间没有访问下会自动断开连接，导致浏览出错，增加proxool作为数据库pool。它有自动连接功能。
1)、从http://proxool.sourceforge...下载proxool，释放proxool.jar到WEB-INF/lib

2)、在hibernate.cfg.xml中增加：

1<property name="hibernate.proxool.pool_alias">dbpoolproperty>
2<property name="hibernate.proxool.xml">proxool.xmlproperty>
3<property name="connection.provider_class">org.hibernate.connection.ProxoolConnectionProviderproperty>
4

3)、在与hibernate.cfg.xml同级目录（src根目录下）增加proxool.xml文件：

1xml version="1.0" encoding="utf-8"?>
2
4<something-else-entirely>
5 <proxool>
6   <alias>dbpoolalias>
7
8   <driver-url>
9     jdbc:mysql://127.0.0.1:3306/wlsh?characterEncoding=GBK&useUnicode=true&autoReconnect=true     driver-url>
10   <driver-class>com.mysql.jdbc.Driverdriver-class>
11   <driver-properties>
12       <property name="user" value="root" />
13       <property name="password" value="123456" />
14   driver-properties>
15
16   <house-keeping-sleep-time>90000house-keeping-sleep-time>
17
18   <prototype-count>5prototype-count>
19
20   <maximum-connection-count>100maximum-connection-count>
21
22   <minimum-connection-count>10minimum-connection-count>
23 proxool>
24something-else-entirely>
25

于在hibernate3.0中，已经不再支持dbcp了，hibernate的作者在hibernate.org中，明确指出在实践中发现dbcp有 BUG,在某些种情会产生很多空连接不能释放，所以抛弃了对dbcp的支持。至于c3p0，有评论说它的算法不是最优的，因为网上查资料得知：有网友做了一个实验，在同一项目中分别用了几个常用的连接池，然后测试其性能，发现c3p0占用资源比较大，效率也不高。所以，基于上述原因，proxool不少行家推荐使用，而且暂时来说，是负面评价是最少的一个。在三星中也有项目是用proxool的。从性能和出错率来说，proxool稍微比前两种好些。C3P0，稳定性似乎不错，在这方面似乎有很好的口碑。至于性能，应该不是最好的，算是中规中矩的类型。
　　Proxool的口碑似乎很好，不大见到负面的评价，从官方资料上来看，有许多有用的特性和特点，也是许多人推荐的。

重归本垒（Bing） 2011-06-12 13:51 发表评论

Hibernate中如何使用count(*)取得表中记录总数

重归本垒（Bing） — Thu, 29 May 2008 06:59:00 GMT

public int getCount(String emailGroupId, String emailBatchId)
            throws HibernateException {

        Session session = HibernateUtil.currentSession();
        Transaction tx = session.beginTransaction();

        String hql = "select count(*) from EmailSendInfo where email_group_id = :emailGroupId and batch_id = :batchId";
        Query query = session.createQuery(hql);

        query.setString("emailGroupId", emailGroupId);
        query.setString("batchId", emailBatchId);
        /**//*
         * for (Iterator it = query.iterate(); it.hasNext();) { return
         * ((Integer) it.next()).intValue(); }
         */
        try {
            return ((Integer) query.iterate().next()).intValue();
        } catch (Exception e) {
            throw new HibernateException("");
        } finally {
            tx.commit();
            HibernateUtil.closeSession();
        }
    }

spring+hibernate

//第一种方法：
  String hql = "select count(*) from User as user";
  Integer count = (Integer)getHibernateTemplate().find(hql).listIterator().next();
  return count.intValue();

//第二种方法：
String hql = "select count(*) from User as user";
  return ((Integer)getHibernateTemplate().iterate(hql).next()).intValue();

//第三种方法：
String hql = "select count(*) from User as user";
Query query =  getHibernateTemplate().createQuery( getSession(),hql);
return ((Integer)query.uniqueResult()).intValue();

重归本垒（Bing） 2008-05-29 14:59 发表评论

error:java.lang.ClassNotFoundException: org.apache.commons.dbcp.BasicDataSource

重归本垒（Bing） — Wed, 12 Sep 2007 07:16:00 GMT

java.lang.ClassNotFoundException: org.apache.commons.dbcp.BasicDataSource
很显然这是一个没有找到对应的类文件的异常。
还有两个包commons-pool.jar和commons-dbcp-1.2.1.jar需要引入到工程中。

重归本垒（Bing） 2007-09-12 15:16 发表评论

在你的struts应用中施展部分AJAX魔法(翻译)[转]

重归本垒（Bing） — Tue, 31 Jul 2007 08:33:00 GMT

本文将介绍在JSP页面中包含一些JavaScript这样一个简单而有效的方法来结合AJAX和Struts。在此我们介绍如何重新使用已经存在的Struts actions，但此技术同样可用于你选择的其他Java-Web 框架。本方法同样可平移到Struts或者JSF的下一个版本。

AJAX是“异步的JavaScript和XML”的缩写。这是一项技术，而不是一个如Struts一样的框架。为什么在AJAX周围会有这么多的关注呢?这是因为AJAX使web页面看起来并不像一个平面的文档，而更像用户所期望的如桌面应用的动态GUI应用程序。AJAX技术能在很多的浏览器上使用(包括IE和Netscape/Mozilla)。它已经为Microsoft(用于Outlook的web客户端)和Google(用户Google Maps和Gmail)所使用。

　　未使用AJAX之前

　　目前大多数的Struts应用都是标准的“如同一个平面文档的web页面”的结构。如果你想模仿一些桌面应用程序(比如那些使用Java Swing，Visual Basic，或者Delphi建立的应用程序)，那么你有两个选择:你可以发送所有的可能作为页面的一部分被请求的信息，使用大量的JavaScript来操作其动态的显示(一个很慢并且非企业级Java的方法);或者你可以不改变形式地提交到后台服务器(一种有效的方法) 。AJAX提高给你了融合前面的最佳解决方案:动态的页面，但是大多数的应用是在你的web服务器的Java程序来处理的。

　　AJAX 101

　　AJAX和现有的动态HTML技术非常相似，并在其上增加了一个发送到“后台”服务器的请求来获取需要的新的或者更新的信息。AJAX的机制在其他地方已经有详细的说明――请查看本文后的Resources来获取更多。但是你至少需要知道:

　　1. XMLHttpRequest (如果你使用的是IE浏览器的话，则是Microsoft.XMLHTTP的ActiveX的对象)。这些对象，你可以在web页面中使用JavaScript调用。他们允许你作为后台的调用方式来请求web服务器的内容(例如，在表单提交后，屏幕并不像平时一样显示“空白”)。
　　2. XMLHttpRequest 和Microsoft.XMLHTTP 返回的内容可以作为XML或者文本来处理。JavaScript(在你页面上的)可以使用请求的新内容来更新页面。
　　3. 整个处理过程可以由普通的JavaScript事件来触发:onclick，onchange，onblur，等。

　　在你的Struts应用中使用AJAX

　　你阅读了本文，然后你会对使用AJAX来创建动态的web页面感兴趣，并且想知道如何将它加入到你的Struts应用中。这只是选择之一。那么你会如何选择呢?

　　· 等待，知道Struts的下一个版本融合了AJAX技术。如果Struts开发者准备开发一个新的应用，这或许会是一个好的选择。再后面，可能会是要求JSF也这样做――对其本身并不一件坏事，但是对于已经存在的系统这将会带来最根本的改变。
　　· 你也可以直接采用新的方法，比如Direct Web Remoting (DWR) 和Ruby on Rails，这些都是专为建立AJAX应用的。如果你考虑不使用Struts来开发web的话，那么这些都是很又用的框架，并且值得一试。但是，这也同时意味着你必须要重写你的应用。
　　· 在你已经存在的Struts应用中增加AJAX。既然AJAX只是一项技术而并非框架，那么它就很容易融入到Struts中。作为现有的系统，其稳定性(如，保持现有的库文件)是相当重要的。所以这个方法被推荐，并且我们将在后面详细介绍。

　　我们选择在Struts应用中增加AJAX的优势是:

　　1. 它并不需要任何新的库文件或者服务器代码;只需要使用现有的Struts库文件和action。
　　2. 解决方案中所有部分――JavaScript，XML，Java和Struts――早已为广泛所知。
　　3. 此应用可以一块一块地移植到AJAX;我们可以确定哪些部分对用户有益，并首先将它们更新到动态AJAX显示。

　　实现方案

　　我们如何真正的贯彻我们的选择呢?我们首先应该注意一个“标准的”(没有AJAX)Struts应用是如何工作的。在此应用中，一个一般的事件流程如下:

　　1. 使用点击超链接或者表单的提交按钮，用户发送请求。
　　2. web服务器运行处理请求的Struts Action来生成一个web页面。
　　3. 浏览器显示web页面。
　　4. 当用户点击保存的时候，信息由Struts框架中一个ActionForm类来转换并发送到服务器。
　　5. 然后，Struts框架调用Struts Action来出来请求(如，保存数据到数据库中)。
　　6. 页面再一次回传，处理流程继续。

　　现有的Struts应用

　　一个演示事件流程的简单Struts应用可以在以下地址下载: struts-non-ajax.zip。此基于Struts的应用，是基于用户的输入显示或者隐藏蓝色和绿色的表格。图1显示了载入初始页面的画面。图2显示了用户输入值并点击了提交后的画面。虽然简单，但它已经足以表示一个Struts的工作流程。

　　图 1. 没有AJAX的例子:初始屏幕

　　图 2. 没有AJAX的例子:输入值并点击了提交

服务器端的代码是:一个Struts Action使用struts-config.xml 中定义的值转发到(相同的)JSP。这个例子代码中一些需要注意的地方是:

　　·struts-config.xml文件将所有的请求重定向到http://localhost:8080/struts-non-ajax/(或者和你自己的服务器相同)的index.jsp。
　　· index.jsp 包含了一个两个文本框的Struts form(showBlue和showGreen)。该页面同样包含了标签，但是如同两个文本框被初始化为空，标签之间的内容并不显示。
　　· 用户输入值(true或者false)并点击提交按钮，处理控制(经过Struts框架，读取struts-config.xml)提交到SampleAction类中。
　　·SampleAction记录下值，然后转发到index.jsp。一个成熟的Struts应用可能会处理更多的事情，不如保存或者查询数据库等。
　　· index.jsp 现在重新处理请求;如果ShowBlue或者ShowGreen的值是true，这些表格就显示出来。

　　该应用并没有任何“错误”。类似的Struts项目好多年都是这样做的。但是，我们如何在不添加复杂的JavaScript或者频繁的表单提交的前提下，为此应用增加动态的元素呢?

　　我们的第一个Struts AJAX应用

　　观察下下面的图3和图4。第一眼看上去，它们和前面的例子没有说明区别。它们的不同之处在于，页面载入后(图3)然后文本框中的值改变了，窗体自动提交而不显示空白的，然后在图4中显示结果。普通的提交按钮仍然在，你也可以选择使用它。

　　图 3. 页面载入后的AJAX例子

　　图 4. AJAX调用后的AJAX例子

　　添加AJAX是出奇的容易。服务器端的代码和前面的例子是一样的: 一个Struts的ActionForm来后去数据，一个Struts的Action来执行需要的任务(例如，存储数据库)然后转发到适当的JSP页面来显示结果。

　　继续

　　如果你希望就此停止阅读(跳过这个例子的工作说明)，但是这里的是和你需要转换你的Struts应用到一个Struts-AJAX应用同样的风格:

　　1. 在你的web页面中引入一个Ajax.js (该文件是struts-ajax.zip 例文件中的一部分)。Ajax.js 包含了所有需要发送和接收AJAX调用的JavaScript方法。
　　2. 确保你希望在AJAX调用中更新的web页面的部分包含在标签中，并且给每个标签一个id。
　　3. 当一些事件触发的时候就更新页面(例如，文本框的the onchange()方法)，调用retrieveURL()方法，通过URL传递到需要执行服务器端处理的Struts Action。
　　4. 为了页面的显示/更新，最简单的方法是Struts Action转发回同样的页面。在本例中，showGreen/showBlue 文本框中的onchange()方法来触发AJAX调用。

　　JavaScript方法retrieveURL()调用服务器的Struts(通过URL)，获取JSP响应，然后更新显示页面中的标签中的部分。就是这么简单!

　　AJAX解决方案的细节

　　我们将例子变为AJAX-Struts应用的时候，需要三个变化:

　　1. 增加一个JavaScript方法来完成到服务器的“背后的”AJAX调用。
　　2. 增加JavaScript代码来接收服务器的响应并更新页面。
　　3. 在JSP页面增加标签标签，这个标签中内容将在AJAX调用中更新。

　　我们将详细的说明上面的每一步。

发送AJAX请求到服务器

　　有两个方法(在下面列出)用于发送请求到服务器。

　　· retrieveURL()方法获得服务器的URL和Struts form。URL用于使用AJAX，form的值用于传递到服务器。

　　· getFormAsString()方法用于将retrieveURL()中form命名的值组装成查询字符串，并发送到服务器。

　　使用方法很简单，使用onclick()/onChange()事件来触发retrieveURL()更新显示。

　　在这两个方法中有一些有趣的东西。

　　在retrieveURL()方法中，req.onreadystatechange = processStateChange (注意，没有括号)这一行来告诉浏览器在服务器响应到达的时候调用processStateChange()方法(该方法将在后面介绍)。retrieveURL()方法中(现在已经是AJAX的标准了)同样决定是使用IE浏览器(ActiveX)还是使用Netscape/Mozilla (XmlHttpRequest) 来实现跨浏览器兼容。

　　getFormAsString()方法将HTML form转换成字符串连接在URL后面(这样就允许我们发送HTTP GET请求)。这个字符串是经过转换的(比如，空格转换成%20等)，并且是一个Struts能将其组装成ActionForm的格式(并不需要Struts清楚的明白这个是来之AJAX的请求)。注意，在本例中我们使用HTTP GET，使用HTTP POST的方法也是类似的。

function retrieveURL(url,nameOfFormToPost) {

//将url转换成字符串
url=url+getFormAsString(nameOfFormToPost);

//调用AJAX
if (window.XMLHttpRequest) {

// 非IE浏览器
req = new XMLHttpRequest();
req.onreadystatechange = processStateChange;
try {
req.open("GET", url, true);
} catch (e) {
alert("Server Communication Problem\n"+e);
}
req.send(null);
} else if (window.ActiveXObject) {
// IE

req = new ActiveXObject("Microsoft.XMLHTTP");
if (req) {
req.onreadystatechange=processStateChange;
req.open("GET", url, true);
req.send();
}
}
}

getFormAsString() 是一个“私有” 方法，在retrieveURL()中使用。

function getFormAsString(formName){

//设置返回字符串
returnString ="";

//取得表单的值
formElements=document.forms[formName].elements;

//循环数组，组装url
//像'/strutsaction.do&name=value'这样的格式

for(var i=formElements.length-1;i>=0; --i ){
//转化每一个值
returnString+="&"
+escape(formElements[i].name)+"="
+escape(formElements[i].value);
}

//返回字符串
return returnString;
}

根据AJAX的响应更新web页面

　　到现在为止，我们学习过了使用JavaScript来完成AJAX调用(前面列出)，Struts Action，ActionForm以及JSP(基本没有变化，只是增加了标签)。为了完善我们对Struts-AJAX项目的了解，我们需要了解三个用于根据服务器返回的结果而更新页面的JavaScript方法。

　　· processStateChange(): 该方法在AJAX调用前设定。它在服务器响应到达后由XMLHttpRequest/Microsoft.XMLHTTP 对象调用。
　　·splitTextIntoSpan(): 根据响应，循环取出数组中的元素组装成NewContent。
　　·replaceExistingWithNewHtml(): 根据span元素数组，循环搜索，将里面的元素调换掉页面中和它的'someName'相同的中的内容。注意，我们使用的是req.responseText 方法来获得返回的内容(它允许我们操作任何文本的响应)。与此相对于的是req.responseXml (它的作用更大，但是要求服务器返回是XHTML或者XML)。

function processStateChange() {

if (req.readyState == 4) { // 完成
if (req.status == 200) { // 响应正常

//将响应的文本分割成Span元素
spanElements =
splitTextIntoSpan(req.responseText);

//使用这些Span元素更新页面
replaceExistingWithNewHtml(spanElements);

} else {
alert("Problem with server response:\n "
+ req.statusText);
}
}
}
replaceExistingWithNewHtml() 是为processStateChange()使用的“私有”方法。

function replaceExistingWithNewHtml
(newTextElements){

//循环newTextElements
for(var i=newTextElements.length-1;i>=0;--i){

//判断是否以 if(newTextElements[i].
indexOf("-1){

//获得span的名字- 设置在第一和第二个引号之间
//确认span元素是以下的格式
//NewContent
startNamePos=newTextElements[i].
indexOf('"')+1;
endNamePos=newTextElements[i].
indexOf('"',startNamePos);
name=newTextElements[i].
substring(startNamePos,endNamePos);

//获得内容－在第一个>标记后的所有内容
startContentPos=newTextElements[i].
indexOf('>')+1;
content=newTextElements[i].
substring(startContentPos);

//现在更新现有的Document中的元素，
// 确保文档存在该元素
if(document.getElementById(name)){
document.getElementById(name).
innerHTML = content;
}
}
}
splitTextIntoSpan() 是为processStateChange() 使用的“私有”方法。
function splitTextIntoSpan(textToSplit){

//分割文档
returnElements=textToSplit.
split("")

//处理每个元素
for(var i=returnElements.length-1;i>=0;--i){

//删除掉第一个span后面的元素
spanPos = returnElements[i].
indexOf("

//如果找到匹配的，获得span前的内容
if(spanPos>0){
subString=returnElements[i].
substring(spanPos);
returnElements[i]=subString;
}
}
return returnElements;
}

　　新的控制流

　　添加以下的JavaScript代码到我们的应用中，以下的步骤将在服务器和浏览器中执行。

　　1. 如同一个普通Struts应用装载页面。
　　2. 用户改变文本框的值，触发一个onChange() 事件，调用retrieveURL() 方法。
　　3. 该JavaScript方法通过发送Struts明白的表单变量(后台)请求到服务器的Struts Action。
　　4. 该JavaScript方法同样设定了第二个JavaScript方法的名字，此方法将到服务器响应完毕后调用。本例子中，设定为processStateChange() 方法。
　　5. 如我们所预期的，服务器响应完毕，调用processStateChange() 方法。
　　6. JavaScript在(新的)服务器响应中循环取出所有元素。将页面上存在与获得元素名字相同的中的元素替换掉。

　　在你的应用中设计AJAX

　　以上描述的JavaScript方法能在大多数的应用中使用，包括比我们的例子复杂得多的。但是，在使用之前，你需要注意以下几点:

　　· 避免复制代码，最好在初始化请求(如，显示完整的页面)和AJAX(更新部分页面)请求中使用相同的Struts Action和JSP。

　　·在公共的Action(控制器)中，决定JSP页面(所有的JSP页面或者其中的一部分)中的一个区域需要传送到浏览器。通过在web服务器的session或者ActionForm中设定标记来让JSP页面知道哪些部分需要提交。

　　· 在JSP中，使用Struts 或者JSTL标签来决定提交的HTML区域。

　　使用AJAX的本例子，可以在以下下载: struts-Ajax.zip

　　结语

　　AJAX技术允许我们在创建和使用web应用的时候完全的改变。本文介绍了一个简单的技术，在现有的Struts应用中增加Struts的处理。它允许我们利用我们已有的东西，不仅仅是代码，还包括了开发的技能。作为一个好的产品，它同样允许我们写出更清晰，更具移植性的Java Struts应用。

版权声明：Techtarget获Matrix授权发布,如需转载请联系Matrix
作者:作者:Paul Browne;pawenwen(作者的blog:http://blog.matrix.org.cn/page/pawenwen)
译文:点击

重归本垒（Bing） 2007-07-31 16:33 发表评论

在Servlet与JSP中取得当前文件所在的相对路径与绝对路径（路径相关）

重归本垒（Bing） — Fri, 27 Jul 2007 04:23:00 GMT

System.out.println("根目录所对应的绝对路径:" + request.getServletPath() + "");
String strPathFile = request.getSession().getServletContext().getRealPath(request.getRequestURI());
System.out.println("文件的绝对路径:" + strPathFile + "");
String strDirPath = new File(request.getSession().getServletContext().getRealPath(request.getRequestURI())).getParent();
System.out.println("目录的绝对路径:" + strDirPath + "");
this.getServlet().getServletContext().getRealPath("/");//在struts的action中取得当前系统的根目录

　举例：http://localhost:7001/myservlet/somepath/test?someparam=somevalue
request.getPathInfo()：返回/somepath/test
request.getRequestURL()：返回http://localhost:7001/myservlet/somepath/test
request.getRequestURI()：返回/myservlet/somepath/test
request.getServletPath()：返回/myservlet
request.getQueryString()：返回someparam=somevalue
request.getContextPath(); 返回项目名/myservlet

重归本垒（Bing） 2007-07-27 12:23 发表评论

Struts+FCKeditor修改读取的html文本

重归本垒（Bing） — Wed, 25 Jul 2007 02:06:00 GMT

因为<bean:write　默认的filter是true。表示把html敏感标签转换成转换成它们实体的等价物。如<转换成<。设为false则不转换。

         <FCK:editor id="classContent" basePath="/ECR_WWW/FCKeditor/"
         width="500"
         height="500"
         skinPath="/ECR_WWW/FCKeditor/editor/skins/silver/"
         >

         <bean:write name="articleAdminForm" property="classContent" filter="false"/>
        FCK:editor>

重归本垒（Bing） 2007-07-25 10:06 发表评论

FCKeditor2.4 JSP版使用[转]

重归本垒（Bing） — Tue, 24 Jul 2007 09:58:00 GMT

1.下载
FCKeditor2.3 (FCKeditot for java)
FCKeditor2.4 (FCKeditor基本文件)
以下是下载地址：
http://www.fckeditor.net/download/default.html

2.建立项目:
建立项目tomcat/webapps/TestFCKeditor.

3.将FCKeditor2.4解压缩
将FCKeditor2.4解压缩,将整个目录FCKeditor复制到项目的根目录下，并将解压缩出来的文件夹fckeditor重命名为FCKeditor
目录结构为：tomcat/webapps/TestFCKeditor/FCKeditor
然后将FCKeditor-2.3.zip（java）压缩包中\web\WEB-INF\lib\目录下的两个jar文件拷到项目的\WEB-INF\ lib\目录下。把其中的src目录下的FCKeditor.tld文件copy到TestFCKedit/WEB-INF/下

4.合并web.xml:
将FCKeditor-2.3.zip压缩包中\web\WEB-INF\目录下的web.xml文件合并到项目的\WEB-INF\目录下的web.xml文件中。

5. 修改合并后的web.xml文件
修改合并后的web.xml文件，将名为SimpleUploader的Servlet的enabled参数值改为true，
以允许上传功能，Connector Servlet的baseDir参数值用于设置上传文件存放的位置。
在web.xml最后添加标签定义:

/TestFCKeditor
/WEB-INF/FCKeditor.tld

现在的web.xml文件没有标签了，应该直接在jsp文件中使用：<%@ taglib uri="http://fckeditor.net/tags-fckeditor" prefix="FCK" %>

6. 映射:
上面文件中两个servlet的映射分别为：/editor/filemanager/browser/default/connectors/jsp/connector
和/editor/filemanager/upload/simpleuploader，需要在两个映射前面加上/FCKeditor，
即改为/FCKeditor/editor/filemanager/browser/default/connectors/jsp/connector和
/FCKeditor/editor/filemanager/upload/simpleuploader。
这两个名字根据你放在工程中的FCKeditor文件夹名称而定。。

7.修改skin文件夹
进入skin文件夹，如果你想使用fckeditor默认的这种奶黄色，
那就把除了default文件夹外的另两个文件夹直接删除.（建议不删除，以后要用到其中的一个文件夹）

8.删除无用文件
删除/FCKeditor/目录下除fckconfig.js, fckeditor.js, fckstyles.xml, fcktemplates.xml四个文件以外的所有文件，保留文件夹editor
删除目录/editor/_source,
删除/editor/filemanager/browser/default/connectors/下的所有文件
删除/editor/filemanager/upload/下的所有文件
删除/editor/lang/下的除了fcklanguagemanager.js（我下载的没有这个文件）, en.js, zh.js, zh-cn.js四个文件的所有文件

9.修改配置：
打开/FCKeditor/fckconfig.js
修改 FCKConfig.DefaultLanguage = 'zh-cn' ;
把FCKConfig.LinkBrowserURL等的值替换成以下内容：
FCKConfig.LinkBrowserURL
= FCKConfig.BasePath + "filemanager/browser/default/browser.html?Connector=connectors/jsp/connector" ;

FCKConfig.ImageBrowserURL
= FCKConfig.BasePath + "filemanager/browser/default/browser.html?Type=Image&Connector=connectors/jsp/connector" ;

FCKConfig.FlashBrowserURL
= FCKConfig.BasePath + "filemanager/browser/default/browser.html?Type=Flash&Connector=connectors/jsp/connector" ;

FCKConfig.LinkUploadURL = FCKConfig.BasePath + 'filemanager/upload/simpleuploader?Type=File' ;
FCKConfig.FlashUploadURL = FCKConfig.BasePath + 'filemanager/upload/simpleuploader?Type=Flash' ;
FCKConfig.ImageUploadURL = FCKConfig.BasePath + 'filemanager/upload/simpleuploader?Type=Image' ;

10.其它
fckconfig.js总配置文件，可用记录本打开，修改后将文件存为utf-8 编码格式。找到：

FCKConfig.TabSpaces = 0 ; 改为FCKConfig.TabSpaces = 1 ; 即在编辑器域内可以使用Tab键。

如果你的编辑器还用在网站前台的话，比如说用于留言本或是日记回复时，那就不得不考虑安全了，
在前台千万不要使用Default的toolbar，要么自定义一下功能，要么就用系统已经定义好的Basic，
也就是基本的toolbar，找到：
FCKConfig.ToolbarSets["Basic"] = [
['Bold','Italic','-','OrderedList','UnorderedList','-',/*'Link',*/'Unlink','-','Style','FontSize','TextColor','BGColor','-',
'Smiley','SpecialChar','Replace','Preview'] ] ;
这是改过的Basic，把图像功能去掉，把添加链接功能去掉，因为图像和链接和flash和图像按钮添加功能都能让前台
页直接访问和上传文件， fckeditor还支持编辑域内的鼠标右键功能。

FCKConfig.ContextMenu = ['Generic',/*'Link',*/'Anchor',/*'Image',*/'Flash','Select','Textarea','Checkbox','Radio','TextField','HiddenField',
/*'ImageButton',*/'Button','BulletedList','NumberedList','TableCell','Table','Form'] ;

这也是改过的把鼠标右键的“链接、图像，FLASH，图像按钮”功能都去掉。

　　找到： FCKConfig.FontNames = 'Arial;Comic Sans MS;Courier New;Tahoma;Times New Roman;Verdana' ;
加上几种我们常用的字体
FCKConfig.FontNames
= '宋体;黑体;隶书;楷体_GB2312;Arial;Comic Sans MS;Courier New;Tahoma;Times New Roman;Verdana' ;

11.添加文件
添加文件 /TestFCKeditor/test.jsp:
<%@ page language="java" import="com.fredck.FCKeditor.*" %>
<%@ taglib uri="/TestFCKeditor" prefix="FCK" %>

<%--
三种方法调用FCKeditor
1.FCKeditor自定义标签 (必须加头文件 <%@ taglib uri="/TestFCKeditor" prefix="FCK" %> )
2.script脚本语言调用 (必须引用脚本文件 )
3.FCKeditor API 调用 (必须加头文件 <%@ page language="java" import="com.fredck.FCKeditor.*" %> )
--%>

//标签调用方式
<%--

--%>

//JS调用方式

//FCKeditor API 调用
<%--

--%>

添加文件/TestFCKeditor/show.jsp:
<%
String content = request.getParameter("content");
out.print(content);
%>

12.测试
浏览http://localhost:8080/TestFCKeditor/test.jsp

最后注意。。不同的版本变量名称可能不一样。请参考你使用的API文档

配置选项:

AutoDetectLanguage=true/false 自动检测语言
BaseHref="" 相对链接的基地址
ContentLangDirection="ltr/rtl" 默认文字方向
ContextMenu=字符串数组,右键菜单的内容
CustomConfigurationsPath="" 自定义配置文件路径和名称
Debug=true/false 是否开启调试功能,这样,当调用FCKDebug.Output()时,会在调试窗中输出内容
DefaultLanguage="" 缺省语言
EditorAreaCss="" 编辑区的样式表文件
EnableSourceXHTML=true/false 为TRUE时,当由可视化界面切换到代码页时,把HTML处理成XHTML
EnableXHTML=true/false 是否允许使用XHTML取代HTML
FillEmptyBlocks=true/false 使用这个功能,可以将空的块级元素用空格来替代
FontColors="" 设置显示颜色拾取器时文字颜色列表
FontFormats="" 设置显示在文字格式列表中的命名
FontNames="" 字体列表中的字体名
FontSizes="" 字体大小中的字号列表
ForcePasteAsPlainText=true/false 强制粘贴为纯文本
ForceSimpleAmpersand=true/false 是否不把&符号转换为XML实体
FormatIndentator="" 当在源码格式下缩进代码使用的字符
FormatOutput=true/false 当输出内容时是否自动格式化代码
FormatSource=true/false 在切换到代码视图时是否自动格式化代码
FullPage=true/false 是否允许编辑整个HTML文件,还是仅允许编辑BODY间的内容
GeckoUseSPAN=true/false 是否允许SPAN标记代替B,I,U标记
IeSpellDownloadUrl=""下载拼写检查器的网址
ImageBrowser=true/false 是否允许浏览服务器功能
ImageBrowserURL="" 浏览服务器时运行的URL
ImageBrowserWindowHeight="" 图像浏览器窗口高度
ImageBrowserWindowWidth="" 图像浏览器窗口宽度
LinkBrowser=true/false 是否允许在插入链接时浏览服务器
LinkBrowserURL="" 插入链接时浏览服务器的URL
LinkBrowserWindowHeight=""链接目标浏览器窗口高度
LinkBrowserWindowWidth=""链接目标浏览器窗口宽度
Plugins=object 注册插件
PluginsPath="" 插件文件夹
ShowBorders=true/false 合并边框
SkinPath="" 皮肤文件夹位置
SmileyColumns=12 图符窗列数
SmileyImages=字符数组图符窗中图片文件名数组
SmileyPath="" 图符文件夹路径
SmileyWindowHeight 图符窗口高度
SmileyWindowWidth 图符窗口宽度
SpellChecker="ieSpell/Spellerpages" 设置拼写检查器
StartupFocus=true/false 开启时FOCUS到编辑器
StylesXmlPath="" 设置定义CSS样式列表的XML文件的位置
TabSpaces=4 TAB键产生的空格字符数
ToolBarCanCollapse=true/false 是否允许展开/折叠工具栏
ToolbarSets=object 允许使用TOOLBAR集合
ToolbarStartExpanded=true/false 开启是TOOLBAR是否展开
UseBROnCarriageReturn=true/false 当回车时是产生BR标记还是P或者DIV标记

解决上传乱码:
在SimpleUploaderServlet.java和ConnectorServlet.java两个文件里找到
DiskFileUpload upload = new DiskFileUpload();
分别在其后加入 upload.setHeaderEncoding("utf-8");
这样解决了文件上传的中文乱码问题.
但是在控制台显示的中文内容还是乱码,但是没关系,我们没必要去看控制台下的中文

----------------------------------------------------------------another
FCKeditor2.4.2 Java版使用说明
下载地址以及基本配置请参考：http://hi.baidu.com/wain19/blog/item/c33fb0fab74f24dfb48f312d.html

我的开发环境是ubuntu7.04, 系统默认编码是utf-8,
期间，本人遇到了下面这些问题：

问题一：XML request error: Internel Server Error(500)

出现错误的地方是在：点插入图片，点Browse按钮的时候：
XML request error: Internel Server Error(500)

找资料：http://lamono.javaeye.com/blog/49135
拷贝xalan.jar和serialize.jar到/WEB-INF/lib，问题解决。

FCKeditor-java没有很好的解决中文问题。需要我们修改它的源代码后重新编译打包。打包过程如下：
1。新建一个web工程名字为FCKeditor-java-2.3，然后把FCKeditor-2.3-java.zip解压缩后的代码拷贝到工程目录下。
2。如果是用的Eclipse,使用快捷键Ctrl+Shift+R
在SimpleUploaderServlet.java和ConnectorServlet.java两个文件里找到
DiskFileUpload upload = new DiskFileUpload();
分别在其后加入 upload.setHeaderEncoding("utf-8");
现在如果直接运行ant任务，会报下面的错误：
taskdef class org.apache.catalina.ant.DeployTask cannot be found

3。把tomcat安装目录下/server/lib中的catalina-ant.jar拷贝到/WEB-INF/lib目录下。
4。打开build.xml
找到
修改成你自己的tomcat安装目录

找到
修改成如下内容

运行ant任务dist, 就可以生成新的FCKeditor-2.3.jar包

问题三：上传时新建的中文目录全部乱码。虽然上传到服务器上的文件名正常，但在JSP页面点下载链接时文件名乱码导致不能正常下载。

查找资料：TOMCAT 链接参数有中文时，乱码解决方法
http://hi.baidu.com/jadestone/blog/item/7564deefc9192d36acafd5be.html
修改tomcat-home/conf/server.xml
方法一:
在两处地方加上URIEncoding="utf-8"：
                   maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false" redirectPort="8443" acceptCount="100"
               debug="0" connectionTimeout="20000"
               disableUploadTimeout="true" URIEncoding="utf-8" />

                   enableLookups="false" redirectPort="8443" debug="0"
               protocol="AJP/1.3" URIEncoding="utf-8" />

方法二:
使用useBodyEncodingForURI="true". 这个方法适合你的TOMCAT实例下需要跑多个不同Encoding的程序时。（有点怀疑？！）
<... maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
       enableLookups="false" redirectPort="8443" acceptCount="100"
      connectionTimeout="20000" disableUploadTimeout="true" useBodyEncodingForURI="true" />

enableLookups="false" redirectPort="8443" protocol="AJP/1.3" useBodyEncodingForURI="true" /

我只试了方法一，问题解决！

这样, FCKeditor终于可以正常使用了。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
=================================================================
以下为个人原创 http://blog.csdn.net/nickshen3/
怎么将FCKeditor2.4使用在自己的web中。
1. 在webapps创建test文件夹。webapps\test
2. 将下载的FCKeditor2.3的Java包FCKeditor-2.3.zip解压缩，并将web文件夹下的两个文件夹_samples，WEB-INF拷贝到刚才建立的webapps\test下。再将src文件夹下的FCKeditor.tld拷贝到WEB-INF下。
3. 在webapps\test\下建立文件夹FCKeditor 。
4. 将刚才下载的 FCKeditor_2.4.3.zip 解压缩，然后将fckeditor文件夹下的 editor（文件夹）,fckconfig.js,fckeditor.js,fckstyles.xml,fcktemplates.xml。四个文件拷贝到刚才建立的文件夹FCKeditor下。
5.修改test\_samples\jsp\sample02.jsp文件，将原来的
改为6.打开tomcat。测试Http://localhost:8080/test/_samples/jsp/sample02.jsp。
ok。

另外： http://www.blogjava.net/youxia/archive/2007/03/15/104077.html

重归本垒（Bing） 2007-07-24 17:58 发表评论

JAVA 如何创建\删除\修改\复制目录及文件 3in1[转]

重归本垒（Bing） — Tue, 24 Jul 2007 05:25:00 GMT

这需要导入java.io类
import java.io.*;

public class FileOperate {
public FileOperate() {
}

/**
   * 新建目录
   * @param folderPath String 如 c:/fqf
   * @return boolean
   */
public void newFolder(String folderPath) {
    try {
      String filePath = folderPath;
      filePath = filePath.toString();
      java.io.File myFilePath = new java.io.File(filePath);
      if (!myFilePath.exists()) {
        myFilePath.mkdir();
      }
    }
    catch (Exception e) {
      System.out.println("新建目录操作出错");
      e.printStackTrace();
    }
}

/**
   * 新建文件
   * @param filePathAndName String 文件路径及名称如c:/fqf.txt
   * @param fileContent String 文件内容
   * @return boolean
   */
public void newFile(String filePathAndName, String fileContent) {

    try {
      String filePath = filePathAndName;
      filePath = filePath.toString();
      File myFilePath = new File(filePath);
      if (!myFilePath.exists()) {
        myFilePath.createNewFile();
      }
      FileWriter resultFile = new FileWriter(myFilePath);
      PrintWriter myFile = new PrintWriter(resultFile);
      String strContent = fileContent;
      myFile.println(strContent);
      resultFile.close();

    }
    catch (Exception e) {
      System.out.println("新建目录操作出错");
      e.printStackTrace();

    }

}

/**
   * 删除文件
   * @param filePathAndName String 文件路径及名称如c:/fqf.txt
   * @param fileContent String
   * @return boolean
   */
public void delFile(String filePathAndName) {
    try {
      String filePath = filePathAndName;
      filePath = filePath.toString();
      java.io.File myDelFile = new java.io.File(filePath);
      myDelFile.delete();

    }
    catch (Exception e) {
      System.out.println("删除文件操作出错");
      e.printStackTrace();

    }

}

/**
   * 删除文件夹
   * @param filePathAndName String 文件夹路径及名称如c:/fqf
   * @param fileContent String
   * @return boolean
   */
public void delFolder(String folderPath) {
    try {
      delAllFile(folderPath); //删除完里面所有内容
      String filePath = folderPath;
      filePath = filePath.toString();
      java.io.File myFilePath = new java.io.File(filePath);
      myFilePath.delete(); //删除空文件夹

    }
    catch (Exception e) {
      System.out.println("删除文件夹操作出错");
      e.printStackTrace();

    }

}

/**
   * 删除文件夹里面的所有文件
   * @param path String 文件夹路径如 c:/fqf
   */
public void delAllFile(String path) {
    File file = new File(path);
    if (!file.exists()) {
      return;
    }
    if (!file.isDirectory()) {
      return;
    }
    String[] tempList = file.list();
    File temp = null;
    for (int i = 0; i < tempList.length; i++) {
      if (path.endsWith(File.separator)) {
        temp = new File(path + tempList[i]);
      }
      else {
        temp = new File(path + File.separator + tempList[i]);
      }
      if (temp.isFile()) {
        temp.delete();
      }
      if (temp.isDirectory()) {
        delAllFile(path+"/"+ tempList[i]);//先删除文件夹里面的文件
        delFolder(path+"/"+ tempList[i]);//再删除空文件夹
      }
    }
}

/**
   * 复制单个文件
   * @param oldPath String 原文件路径如：c:/fqf.txt
   * @param newPath String 复制后路径如：f:/fqf.txt
   * @return boolean
   */
public void copyFile(String oldPath, String newPath) {
    try {
      int bytesum = 0;
      int byteread = 0;
      File oldfile = new File(oldPath);
      if (oldfile.exists()) { //文件存在时
        InputStream inStream = new FileInputStream(oldPath); //读入原文件
        FileOutputStream fs = new FileOutputStream(newPath);
        byte[] buffer = new byte[1444];
        int length;
        while ( (byteread = inStream.read(buffer)) != -1) {
          bytesum += byteread; //字节数文件大小
          System.out.println(bytesum);
          fs.write(buffer, 0, byteread);
        }
        inStream.close();
      }
    }
    catch (Exception e) {
      System.out.println("复制单个文件操作出错");
      e.printStackTrace();

    }

}

/**
   * 复制整个文件夹内容
   * @param oldPath String 原文件路径如：c:/fqf
   * @param newPath String 复制后路径如：f:/fqf/ff
   * @return boolean
   */
public void copyFolder(String oldPath, String newPath) {

    try {
      (new File(newPath)).mkdirs(); //如果文件夹不存在则建立新文件夹
      File a=new File(oldPath);
      String[] file=a.list();
      File temp=null;
      for (int i = 0; i < file.length; i++) {
        if(oldPath.endsWith(File.separator)){
          temp=new File(oldPath+file[i]);
        }
        else{
          temp=new File(oldPath+File.separator+file[i]);
        }

        if(temp.isFile()){
          FileInputStream input = new FileInputStream(temp);
          FileOutputStream output = new FileOutputStream(newPath + "/" +
              (temp.getName()).toString());
          byte[] b = new byte[1024 * 5];
          int len;
          while ( (len = input.read(b)) != -1) {
            output.write(b, 0, len);
          }
          output.flush();
          output.close();
          input.close();
        }
        if(temp.isDirectory()){//如果是子文件夹
          copyFolder(oldPath+"/"+file[i],newPath+"/"+file[i]);
        }
      }
    }
    catch (Exception e) {
      System.out.println("复制整个文件夹内容操作出错");
      e.printStackTrace();

    }

}

/**
   * 移动文件到指定目录
   * @param oldPath String 如：c:/fqf.txt
   * @param newPath String 如：d:/fqf.txt
   */
public void moveFile(String oldPath, String newPath) {
    copyFile(oldPath, newPath);
    delFile(oldPath);

}

/**
   * 移动文件到指定目录
   * @param oldPath String 如：c:/fqf.txt
   * @param newPath String 如：d:/fqf.txt
   */
public void moveFolder(String oldPath, String newPath) {
    copyFolder(oldPath, newPath);
    delFolder(oldPath);

}
}

java中删除目录事先要删除目录下的文件或子目录。用递归就可以实现。这是我第一个用到算法作的程序，哎看来没白学。
public void del(String filepath) throws IOException{
File f = new File(filepath);//定义文件路径
if(f.exists() && f.isDirectory()){//判断是文件还是目录
    if(f.listFiles().length==0){//若目录下没有文件则直接删除
        f.delete();
    }else{//若有则把文件放进数组，并判断是否有下级目录
        File delFile[]=f.listFiles();
        int i =f.listFiles().length;
        for(int j=0;j            if (delFile[j].isDirectory()){                                                del (delFile[j].getAbsolutePath());//递归调用del方法并取得子目录路径
            }
            delFile[j].delete();//删除文件
        }
    }
    del(filepath);//递归调用
}

}

删除一个非空目录并不是简单地创建一个文件对象，然后再调用delete()就可以完成的。要在平台无关的方式下安全地删除一个非空目录，你还需要一个算法。该算法首先删除文件，然后再从目录树的底部由下至上地删除其中所有的目录。

只要简单地在目录中循环查找文件，再调用delete就可以清除目录中的所有文件：

static public void emptyDirectory(File directory) {
   File[ ] entries = directory.listFiles( );
   for(int i=0; i       entries[i].delete( );
   }
}
这个简单的方法也可以用来删除整个目录结构。当在循环中遇到一个目录时它就递归调用deleteDirectory，而且它也会检查传入的参数是否是一个真正的目录。最后，它将删除作为参数传入的整个目录。
static public void deleteDirectory(File dir) throws IOException {
   if( (dir == null) || !dir.isDirectory) {
       throw new IllegalArgumentException(

                 "Argument "+dir+" is not a directory. "
             );
   }

   File[ ] entries = dir.listFiles( );
   int sz = entries.length;

   for(int i=0; i       if(entries[i].isDirectory( )) {
           deleteDirectory(entries[i]);
       } else {
           entries[i].delete( );
       }
   }

dir.delete();
}
在Java 1.1以及一些J2ME/PersonalJava的变种中没有File.listFiles方法。所以只能用File.list，它的返回值一个字符串数组，你要为每个字符串构造一个新的文件对象。

重归本垒（Bing） 2007-07-24 13:25 发表评论

StringUtils工具类的使用[转]

重归本垒（Bing） — Fri, 13 Jul 2007 04:57:00 GMT

一、数组转成字符串：
1、将数组中的字符转换为一个字符串
将数组中的字符转换为一个字符串

@param strToConv 要转换的字符串 ,默认以逗号分隔
@return 返回一个字符串
String[3] s={"a","b","c"}
StringUtil.convString（s)="a,b,c"
2、 static public String converString(String strToConv)
@param strToConv 要转换的字符串 ,
@param conv 分隔符,默认以逗号分隔
@return 同样返回一个字符串

String[3] s={"a","b","c"}
StringUtil.convString（s,"@")="a@b@c"
static public String converString(String strToConv, String conv)

二、空值检测：
3、

Checks if a String is empty ("") or null.

判断一个字符串是否为空，空格作非空处理。 StringUtils.isEmpty(null) = true StringUtils.isEmpty("") = true StringUtils.isEmpty(" ") = false StringUtils.isEmpty("bob") = false StringUtils.isEmpty(" bob ") = false

NOTE: This method changed in Lang version 2.0.

It no longer trims the String.
That functionality is available in isBlank().

@param str the String to check, may be null
@return true if the String is empty or null
public static boolean isEmpty(String str)

三、非空处理：
4、
Checks if a String is not empty ("") and not null.

判断一个字符串是否非空，空格作非空处理. StringUtils.isNotEmpty(null) = false StringUtils.isNotEmpty("") = false StringUtils.isNotEmpty(" ") = true StringUtils.isNotEmpty("bob") = true StringUtils.isNotEmpty(" bob ") = true

@param str the String to check, may be null
@return true if the String is not empty and not null
public static boolean isNotEmpty(String str)

5、

Checks if a String is not empty (""), not null and not whitespace only.

判断一个字符串是否非空，空格作空处理. StringUtils.isNotBlank(null) = false StringUtils.isNotBlank("") = false StringUtils.isNotBlank(" ") = false StringUtils.isNotBlank("bob") = true StringUtils.isNotBlank(" bob ") = true

@param str the String to check, may be null
@return true if the String is
not empty and not null and not whitespace
@since 2.0
public static boolean isNotBlank(String str)

四、空格处理
6、
Removes control characters (char <= 32) from both

ends of this String, handling null by returning
null.

The String is trimmed using {@link String#trim()}.

Trim removes start and end characters <= 32.
To strip whitespace use {@link //strip(String)}.

To trim your choice of characters, use the

{@link //strip(String, String)} methods.

格式化一个字符串中的空格，有非空判断处理； StringUtils.trim(null) = null StringUtils.trim("") = "" StringUtils.trim(" ") = "" StringUtils.trim("abc") = "abc" StringUtils.trim(" abc ") = "abc"

@param str the String to be trimmed, may be null
@return the trimmed string, null if null String input
public static String trim(String str)

7、

Removes control characters (char <= 32) from both

ends of this String returning null if the String is
empty ("") after the trim or if it is null.

The String is trimmed using {@link String#trim()}.

Trim removes start and end characters <= 32.
To strip whitespace use {@link /stripToNull(String)}.

格式化一个字符串中的空格，有非空判断处理，如果为空返回null； StringUtils.trimToNull(null) = null StringUtils.trimToNull("") = null StringUtils.trimToNull(" ") = null StringUtils.trimToNull("abc") = "abc" StringUtils.trimToNull(" abc ") = "abc"

@param str the String to be trimmed, may be null
@return the trimmed String,
null if only chars <= 32, empty or null String input
@since 2.0
public static String trimToNull(String str)

8、

Removes control characters (char <= 32) from both

ends of this String returning an empty String ("") if the String
is empty ("") after the trim or if it is null.

The String is trimmed using {@link String#trim()}.

Trim removes start and end characters <= 32.
To strip whitespace use {@link /stripToEmpty(String)}.

格式化一个字符串中的空格，有非空判断处理，如果为空返回""； StringUtils.trimToEmpty(null) = "" StringUtils.trimToEmpty("") = "" StringUtils.trimToEmpty(" ") = "" StringUtils.trimToEmpty("abc") = "abc" StringUtils.trimToEmpty(" abc ") = "abc"

@param str the String to be trimmed, may be null
@return the trimmed String, or an empty String if null input
@since 2.0
public static String trimToEmpty(String str)

五、字符串比较:
9、
Compares two Strings, returning true if they are equal.

nulls are handled without exceptions. Two null

references are considered to be equal. The comparison is case sensitive.

判断两个字符串是否相等，有非空处理。 StringUtils.equals(null, null) = true StringUtils.equals(null, "abc") = false StringUtils.equals("abc", null) = false StringUtils.equals("abc", "abc") = true StringUtils.equals("abc", "ABC") = false

@param str1 the first String, may be null
@param str2 the second String, may be null
@return true if the Strings are equal, case sensitive, or
both null
@see java.lang.String#equals(Object)
public static boolean equals(String str1, String str2)

10、

Compares two Strings, returning true if they are equal ignoring

the case.

nulls are handled without exceptions. Two null

references are considered equal. Comparison is case insensitive.

判断两个字符串是否相等，有非空处理。忽略大小写 StringUtils.equalsIgnoreCase(null, null) = true StringUtils.equalsIgnoreCase(null, "abc") = false StringUtils.equalsIgnoreCase("abc", null) = false StringUtils.equalsIgnoreCase("abc", "abc") = true StringUtils.equalsIgnoreCase("abc", "ABC") = true

@param str1 the first String, may be null
@param str2 the second String, may be null
@return true if the Strings are equal, case insensitive, or
both null
@see java.lang.String#equalsIgnoreCase(String)
public static boolean equalsIgnoreCase(String str1, String str2)

六、 IndexOf 处理
11、

Finds the first index within a String, handling null.

This method uses {@link String#indexOf(String)}.

A null String will return -1.

返回要查找的字符串所在位置，有非空处理 StringUtils.indexOf(null, *) = -1 StringUtils.indexOf(*, null) = -1 StringUtils.indexOf("", "") = 0 StringUtils.indexOf("aabaabaa", "a") = 0 StringUtils.indexOf("aabaabaa", "b") = 2 StringUtils.indexOf("aabaabaa", "ab") = 1 StringUtils.indexOf("aabaabaa", "") = 0

@param str the String to check, may be null
@param searchStr the String to find, may be null
@return the first index of the search String,
-1 if no match or null string input
@since 2.0
public static int indexOf(String str, String searchStr)

12、

Finds the first index within a String, handling null.

This method uses {@link String#indexOf(String, int)}.

A null String will return -1.

A negative start position is treated as zero.
An empty ("") search String always matches.
A start position greater than the string length only matches
an empty search String.

返回要由指定位置开始查找的字符串所在位置，有非空处理 StringUtils.indexOf(null, *, *) = -1 StringUtils.indexOf(*, null, *) = -1 StringUtils.indexOf("", "", 0) = 0 StringUtils.indexOf("aabaabaa", "a", 0) = 0 StringUtils.indexOf("aabaabaa", "b", 0) = 2 StringUtils.indexOf("aabaabaa", "ab", 0) = 1 StringUtils.indexOf("aabaabaa", "b", 3) = 5 StringUtils.indexOf("aabaabaa", "b", 9) = -1 StringUtils.indexOf("aabaabaa", "b", -1) = 2 StringUtils.indexOf("aabaabaa", "", 2) = 2 StringUtils.indexOf("abc", "", 9) = 3

@param str the String to check, may be null
@param searchStr the String to find, may be null
@param startPos the start position, negative treated as zero
@return the first index of the search String,
-1 if no match or null string input
@since 2.0
public static int indexOf(String str, String searchStr, int startPos)

七、子字符串处理：
13、
Gets a substring from the specified String avoiding exceptions.

A negative start position can be used to start n

characters from the end of the String.

A null String will return null.

An empty ("") String will return "".

返回指定位置开始的字符串中的所有字符 StringUtils.substring(null, *) = null StringUtils.substring("", *) = "" StringUtils.substring("abc", 0) = "abc" StringUtils.substring("abc", 2) = "c" StringUtils.substring("abc", 4) = "" StringUtils.substring("abc", -2) = "bc" StringUtils.substring("abc", -4) = "abc"

@param str the String to get the substring from, may be null
@param start the position to start from, negative means
count back from the end of the String by this many characters
@return substring from start position, null if null String input
public static String substring(String str, int start)

14、

Gets a substring from the specified String avoiding exceptions.

A negative start position can be used to start/end n

characters from the end of the String.

The returned substring starts with the character in the start

position and ends before the end position. All postion counting is
zero-based -- i.e., to start at the beginning of the string use
start = 0. Negative start and end positions can be used to
specify offsets relative to the end of the String.

If start is not strictly to the left of end, ""

is returned.

返回由开始位置到结束位置之间的子字符串 StringUtils.substring(null, *, *) = null StringUtils.substring("", * , *) = ""; StringUtils.substring("abc", 0, 2) = "ab" StringUtils.substring("abc", 2, 0) = "" StringUtils.substring("abc", 2, 4) = "c" StringUtils.substring("abc", 4, 6) = "" StringUtils.substring("abc", 2, 2) = "" StringUtils.substring("abc", -2, -1) = "b" StringUtils.substring("abc", -4, 2) = "ab"

@param str the String to get the substring from, may be null
@param start the position to start from, negative means
count back from the end of the String by this many characters
@param end the position to end at (exclusive), negative means
count back from the end of the String by this many characters
@return substring from start position to end positon,
null if null String input
public static String substring(String str, int start, int end)

15、 SubStringAfter/SubStringBefore（前后子字符串处理：

Gets the substring before the first occurance of a separator.

The separator is not returned.

A null string input will return null.

An empty ("") string input will return the empty string.
A null separator will return the input string.

返回指定字符串之前的所有字符 StringUtils.substringBefore(null, *) = null StringUtils.substringBefore("", *) = "" StringUtils.substringBefore("abc", "a") = "" StringUtils.substringBefore("abcba", "b") = "a" StringUtils.substringBefore("abc", "c") = "ab" StringUtils.substringBefore("abc", "d") = "abc" StringUtils.substringBefore("abc", "") = "" StringUtils.substringBefore("abc", null) = "abc"

@param str the String to get a substring from, may be null
@param separator the String to search for, may be null
@return the substring before the first occurance of the separator,
null if null String input
@since 2.0
public static String substringBefore(String str, String separator)

16、

Gets the substring after the first occurance of a separator.

The separator is not returned.

A null string input will return null.

An empty ("") string input will return the empty string.
A null separator will return the empty string if the
input string is not null.

返回指定字符串之后的所有字符 StringUtils.substringAfter(null, *) = null StringUtils.substringAfter("", *) = "" StringUtils.substringAfter(*, null) = "" StringUtils.substringAfter("abc", "a") = "bc" StringUtils.substringAfter("abcba", "b") = "cba" StringUtils.substringAfter("abc", "c") = "" StringUtils.substringAfter("abc", "d") = "" StringUtils.substringAfter("abc", "") = "abc"

@param str the String to get a substring from, may be null
@param separator the String to search for, may be null
@return the substring after the first occurance of the separator,
null if null String input
@since 2.0
public static String substringAfter(String str, String separator)

17、

Gets the substring before the last occurance of a separator.

The separator is not returned.

A null string input will return null.

An empty ("") string input will return the empty string.
An empty or null separator will return the input string.

返回最后一个指定字符串之前的所有字符 StringUtils.substringBeforeLast(null, *) = null StringUtils.substringBeforeLast("", *) = "" StringUtils.substringBeforeLast("abcba", "b") = "abc" StringUtils.substringBeforeLast("abc", "c") = "ab" StringUtils.substringBeforeLast("a", "a") = "" StringUtils.substringBeforeLast("a", "z") = "a" StringUtils.substringBeforeLast("a", null) = "a" StringUtils.substringBeforeLast("a", "") = "a"

@param str the String to get a substring from, may be null
@param separator the String to search for, may be null
@return the substring before the last occurance of the separator,
null if null String input
@since 2.0
public static String substringBeforeLast(String str, String separator)

18、

Gets the substring after the last occurance of a separator.

The separator is not returned.

A null string input will return null.

An empty ("") string input will return the empty string.
An empty or null separator will return the empty string if
the input string is not null.

返回最后一个指定字符串之后的所有字符 StringUtils.substringAfterLast(null, *) = null StringUtils.substringAfterLast("", *) = "" StringUtils.substringAfterLast(*, "") = "" StringUtils.substringAfterLast(*, null) = "" StringUtils.substringAfterLast("abc", "a") = "bc" StringUtils.substringAfterLast("abcba", "b") = "a" StringUtils.substringAfterLast("abc", "c") = "" StringUtils.substringAfterLast("a", "a") = "" StringUtils.substringAfterLast("a", "z") = ""

@param str the String to get a substring from, may be null
@param separator the String to search for, may be null
@return the substring after the last occurance of the separator,
null if null String input
@since 2.0
public static String substringAfterLast(String str, String separator)

八、 Replacing（字符串替换）
19、
Replaces all occurances of a String within another String.

A null reference passed to this method is a no-op.

以指定字符串替换原来字符串的的指定字符串 StringUtils.replace(null, *, *) = null StringUtils.replace("", *, *) = "" StringUtils.replace("aba", null, null) = "aba" StringUtils.replace("aba", null, null) = "aba" StringUtils.replace("aba", "a", null) = "aba" StringUtils.replace("aba", "a", "") = "aba" StringUtils.replace("aba", "a", "z") = "zbz"

@param text text to search and replace in, may be null
@param repl the String to search for, may be null
@param with the String to replace with, may be null
@return the text with any replacements processed,
null if null String input
@see #replace(String text, String repl, String with, int max)
public static String replace(String text, String repl, String with)

20、

Replaces a String with another String inside a larger String,

for the first max values of the search String.

A null reference passed to this method is a no-op.

以指定字符串最大替换原来字符串的的指定字符串 StringUtils.replace(null, *, *, *) = null StringUtils.replace("", *, *, *) = "" StringUtils.replace("abaa", null, null, 1) = "abaa" StringUtils.replace("abaa", null, null, 1) = "abaa" StringUtils.replace("abaa", "a", null, 1) = "abaa" StringUtils.replace("abaa", "a", "", 1) = "abaa" StringUtils.replace("abaa", "a", "z", 0) = "abaa" StringUtils.replace("abaa", "a", "z", 1) = "zbaa" StringUtils.replace("abaa", "a", "z", 2) = "zbza" StringUtils.replace("abaa", "a", "z", -1) = "zbzz"

@param text text to search and replace in, may be null
@param repl the String to search for, may be null
@param with the String to replace with, may be null
@param max maximum number of values to replace, or -1 if no maximum
@return the text with any replacements processed,
null if null String input
public static String replace(String text, String repl, String with, int max)

九、 Case conversion（大小写转换）
21、

Converts a String to upper case as per {@link String#toUpperCase()}.

A null input String returns null.

将一个字符串变为大写 StringUtils.upperCase(null) = null StringUtils.upperCase("") = "" StringUtils.upperCase("aBc") = "ABC"

@param str the String to upper case, may be null
@return the upper cased String, null if null String input
public static String upperCase(String str) 22、

Converts a String to lower case as per {@link String#toLowerCase()}.

A null input String returns null.

将一个字符串转换为小写 StringUtils.lowerCase(null) = null StringUtils.lowerCase("") = "" StringUtils.lowerCase("aBc") = "abc"

@param str the String to lower case, may be null
@return the lower cased String, null if null String input
public static String lowerCase(String str) 23、

Capitalizes a String changing the first letter to title case as

per {@link Character#toTitleCase(char)}. No other letters are changed.

For a word based alorithm, see {@link /WordUtils#capitalize(String)}.

A null input String returns null.

StringUtils.capitalize(null) = null StringUtils.capitalize("") = "" StringUtils.capitalize("cat") = "Cat" StringUtils.capitalize("cAt") = "CAt"

@param str the String to capitalize, may be null
@return the capitalized String, null if null String input
@see /WordUtils#capitalize(String)
@see /uncapitalize(String)
@since 2.0
将字符串中的首字母大写
public static String capitalize(String str)

重归本垒（Bing） 2007-07-13 12:57 发表评论

使用过滤器(Filter)对请求做统一的认证处理

重归本垒（Bing） — Wed, 04 Jul 2007 01:31:00 GMT

摘要: Filter有要实现的三方法：void init(FilterConfig config) throws ServletExceptionvoid doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletExceptionvoid destroy... 阅读全文

重归本垒（Bing） 2007-07-04 09:31 发表评论

动态WEB应用中的用户SESSION管理方案

重归本垒（Bing） — Wed, 04 Jul 2007 00:59:00 GMT

要有这么一个监听器，当加入session时就可以触发一个加入session事件，在session过期时就可以触发一个删除事件，那么我们的把要处理的东西加入到这两个事件中就可以做很多于SESSION相关连的事。如在线用户的管理，单点登陆等等。
在J2EE中可以实现HttpSessionBindingListener接口，此接口有两要实现的方法。
void valueBound(HttpSessionBindingEvent event) 当实现此接口的监听类和session绑定时触发此事件。
void valueUnbound(HttpSessionBindingEvent event) 当session过期或实现此接口的监听类卸裁时触发此事件。

下面是一个示例解决方案：可以把登陆用户的信息记录在缓冲池中，当SESSION过期时，用户信息自动删除。
一个用户信息接口。一个用户缓冲池。一个HttpSessionBindingListener接口的监听类。

public interface LoginUserMessage {}

public class LoginUserPool {
    private Map map = new HashMap();
    private static LoginUserPool loginUserPool = new LoginUserPool();
    private LoginUserPool(){}
    public static LoginUserPool getInstance() {
        return loginUserPool;
    }
    public void addLoginUserMessage(String sessionId,LoginUserMessage loginUserMessage){
       map.remove(sessionId);
       map.put(sessionId,loginUserMessage);
    }
    public LoginUserMessage removeLoginUserMessage(String sessionId){
        return  (LoginUserMessage) map.remove(sessionId);
    }
    public LoginUserMessage getLoginUserMessage(String sessionId){
        return (LoginUserMessage) map.get(sessionId);
    }
    public Map getLoginUserMessages(){
        return map;
    }
    public boolean isEmpty(){
        return  map.isEmpty();
    }
}

public class UserLoginListener implements HttpSessionBindingListener{
    private final Log logger = LogFactory.getLog(getClass());
    private String sessionId = null;
    private LoginUserMessage loginUserMessage = null;
    private LoginUserPool loginUserPool = LoginUserPool.getInstance();

    public LoginUserMessage getLoginUserMessage() {
        return loginUserMessage;
    }
    public void setLoginUserMessage(LoginUserMessage loginUserMessage) {
        this.loginUserMessage = loginUserMessage;
    }
    public String getSessionId() {
        return sessionId;
    }
    public void setSessionId(String sessionId) {
        this.sessionId = sessionId;
    }
    /* (non-Javadoc)
     * @see javax.servlet.http.HttpSessionBindingListener#valueBound(javax.servlet.http.HttpSessionBindingEvent)
     */
    public void valueBound(HttpSessionBindingEvent event) {
        // TODO Auto-generated method stub
        if(this.getLoginUserMessage() != null){
            loginUserPool.addLoginUserMessage(this.getSessionId(),this.getLoginUserMessage());
            logger.info("用户信息加入缓存池成功");
        }
        this.setLoginUserMessage(null);
    }

    /* (non-Javadoc)
     * @see javax.servlet.http.HttpSessionBindingListener#valueUnbound(javax.servlet.http.HttpSessionBindingEvent)
     */
    public void valueUnbound(HttpSessionBindingEvent event) {
        // TODO Auto-generated method stub
        if(!loginUserPool.isEmpty()){
            loginUserPool.removeLoginUserMessage(sessionId);
            logger.info("用户信息从缓存池中移除成功");
        }
    }

}

这样子的话，当在应用中把userLoginListener加入到session中时，就会自动把用户信息加入到缓冲池中了。
如：
session.setAttribute("userLoginListener",userLoginListener);

（原创，转载请保留文章出处http://www.blogjava.net/bnlovebn/archive/2007/07/04/128006.html）

重归本垒（Bing） 2007-07-04 08:59 发表评论

java调用oracle Package 的Function&Procedure

重归本垒（Bing） — Thu, 17 May 2007 03:48:00 GMT

CREATE OR REPLACE PACKAGE SCOTT.pkg_test as
/* 定义ref cursor类型
不加return类型，为弱类型，允许动态sql查询，
否则为强类型，无法使用动态sql查询;
*/
type myrctype is ref cursor;

--函数申明
function get(intID number) return myrctype;
Procedure getstudent(
        intID number,
       return_list out myrctype
  );
end pkg_test;

==============================================

CREATE OR REPLACE PACKAGE BODY SCOTT.pkg_test as
--函数体
    function get(intID number) return myrctype is
        rc myrctype; --定义ref cursor变量
        sqlstr varchar2(500);
        begin
            if intID=0 then
                --静态测试，直接用select语句直接返回结果
                open rc for select id,name,sex,address,postcode,birthday from student;
            else
                --动态sql赋值，用:w_id来申明该变量从外部获得
                sqlstr :='select id,name,sex,address,postcode,birthday from student where id=:w_id';
                --动态测试，用sqlstr字符串返回结果，用using关键词传递参数
                open rc for sqlstr using intid;
            end if;

        return rc;
    end get;

  Procedure getstudent(
         intID number,
       return_list out myrctype
  )as

   begin
       open return_list
       for
        select id,name,sex,address,postcode,birthday from student;
  end getstudent;

end pkg_test;
/

        try {
            conn.setAutoCommit(false);
            CallableStatement proc = conn
                    .prepareCall("{call  pkg_test.getstudent(?,?)}");
            proc.setInt(1, 1);
            proc.registerOutParameter(2, OracleTypes.CURSOR);
            proc.execute();
            ResultSet rs = (ResultSet) proc.getObject(2);
            while (rs.next()) {
                System.out.println(rs.getString(2));
            }
        } catch (SQLException e) {
            // TODO 自动生成 catch 块
            e.printStackTrace();
        }
        try {
            conn.setAutoCommit(false);
            CallableStatement proc = conn
                    .prepareCall("{call ? := pkg_test.get(?)}");
            proc.setInt(2, 0);
            proc.registerOutParameter(1, OracleTypes.CURSOR);
            proc.execute();
            ResultSet rs = (ResultSet) proc.getObject(1);
            while (rs.next()) {
                System.out.println(rs.getString(2));
            }
        } catch (SQLException e) {
            // TODO 自动生成 catch 块
            e.printStackTrace();
        }

重归本垒（Bing） 2007-05-17 11:48 发表评论

Spring+XFire+JUnit配制Web Service并在client测试.

重归本垒（Bing） — Fri, 30 Mar 2007 02:11:00 GMT

摘要: 一、先看目录结构。-xfire +src -war -WEB-INF +class &... 阅读全文

重归本垒（Bing） 2007-03-30 10:11 发表评论

JSP文件下载的几种方式

重归本垒（Bing） — Mon, 12 Feb 2007 05:41:00 GMT

１。最直接最简单的，方式是把文件地址直接放到html页面的一个链接中。这样做的缺点是把文件在服务器上的路径暴露了，并且还无法对文件下载进行其它的控制（如权限）。这个就不写示例了。
２。在服务器端把文件转换成输出流，写入到response，以response把文件带到浏览器，由浏览器来提示用户是否愿意保存文件到本地。（示例如下）

<%
response.setContentType(fileminitype);
response.setHeader("Location",filename);
response.setHeader("Cache-Control", "max-age=" + cacheTime);
response.setHeader("Content-Disposition", "attachment; filename=" + filename); //filename应该是编码后的(utf-8)
response.setContentLength(filelength);
OutputStream outputStream = response.getOutputStream();
InputStream inputStream = new FileInputStream(filepath);
byte[] buffer = new byte[1024];
int i = -1;
while ((i = inputStream.read(buffer)) != -1) {
outputStream.write(buffer, 0, i);
}
outputStream.flush();
outputStream.close();
inputStream.close();
outputStream = null;

%>

３。既然是JSP的话，还有一种方式就是用Applet来实现文件的下载。不过客户首先得信任你的这个Applet小程序，由这个程序来接受由servlet发送来的数据流，并写入到本地。
servlet端示例

    public void service(HttpServletRequest req, HttpServletResponse res)
            throws ServletException, IOException {
        res.setContentType(" text/plain ");
        OutputStream outputStream = null;
        try {
            outputStream = res.getOutputStream();
            popFile(srcFile, outputStream)) ;//把文件路径为srcFile的文件写入到outputStream中。
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

JApplet端示例

   URLConnection con;
        try {
            con = url.openConnection();//url是被调用的SERVLET的网址如http://localhost:8080/sendDateSevlet.do
            con.setUseCaches(false);
            con.setDoInput(true);
            con.setDoOutput(true);
            con.setRequestProperty("Content-Type",
                "application/octet-stream");
            InputStream in = con.getInputStream();
            ProgressMonitorInputStream pmInputStream = new ProgressMonitorInputStream(
                    pane, "正在从服务器下载文件内容", in);
            ProgressMonitor pMonitor = pmInputStream
                    .getProgressMonitor();
            pMonitor.setMillisToDecideToPopup(3);
            pMonitor.setMillisToPopup(3);
            String localfilepath = localstr + filename ;//localfilepath本地路径,localstr文件文件夹，filename本地文件名
   　　if(saveFilsaveFilee(localfilepath,pmInputStream)){　//方法saveFilsaveFilee是把输入流pmInputStream写到文件localfilepath中。
　　　　　openLocalFile(localfilepath);
            }

４。顺便把JApplet上传文件的代码也贴上来.
JApplet端示例

URLConnection con;
        try {
            con = url.openConnection();//url是被调用的SERVLET的网址如http://localhost:8080/sendDateSevlet.do
　　   con.setUseCaches(false);
            con.setDoInput(true);
            con.setDoOutput(true);
            con.setRequestProperty("Content-Type",
                "application/octet-stream");

            OutputStream out = con.getOutputStream();
            String localfilepath = localstr + filename; //localfilepath本地路径,localstr文件文件夹，filename本地文件名
            getOutputStream(localfilepath,out);//文件getOutputStream是把文件localfilepath写到输出流out中。
            InputStream in = con.getInputStream();
            return true;
        }catch (IOException e) {
               System.out.println("文件上传出错！");
            e.printStackTrace();
        }

servlet端代码示例

    public void service(HttpServletRequest req, HttpServletResponse res)
            throws ServletException, IOException {
        res.setContentType(" text/plain ");
        InputStream inputStream = null;
        try {
            inputStream = res.getInputStream();
            writefile(srcFile, inputStream);//把输入流inputStream保存到文件路径为srcFile的文件中
        } catch (IOException e) {
            e.printStackTrace();
        }
    } // end service

总结：在文件的传输中是流的形式存在的，在硬盘上是文件的形式存在的。我们要做的只是通过HttpServletRequest和HttpServletResponse，或者是response和request来发送流和读取流。以及把文件转换成流或把流转换成文件的操作。

重归本垒（Bing） 2007-02-12 13:41 发表评论

Eclipse中classpath和link配制总结

重归本垒（Bing） — Thu, 21 Dec 2006 07:26:00 GMT

      在eclipse中要想正确的运行应用程序，首先要做的就是把相关的类库，类文件包含进来，以及其它配制文件link进来。

      在eclipse中可以非常方便的做到。

      在工程文件目录中点右键，打开“构建路径”——>“配制构建路径”，就可以进行相关的类库，类文件，配制文件的设置。

      在“库”中可以加入编译运行时需要的类库，在“源代码”中可以link入编译运行需要的类，同时还要吧设置源文件的位置以及输出位置。在“项目”中可以加入运行时依赖的其它project。在“排序和导出”可以对设置好的类库，类文件，配制文件进行排序，可以设定哪些文件要导出到硬盘上。

重归本垒（Bing） 2006-12-21 15:26 发表评论

一个applet——servlet通讯的例子

重归本垒（Bing） — Tue, 12 Dec 2006 02:43:00 GMT

摘要: ---servlet文件 import java.io. * ; import java.util.Date; import javax.servlet. * ; import javax.servlet.http. * ;... 阅读全文

重归本垒（Bing） 2006-12-12 10:43 发表评论

给自己的jar创建一个密钥

重归本垒（Bing） — Tue, 12 Dec 2006 01:51:00 GMT

1.文件打包

      jar cf myname.jar *.class

2.证书位置

自签名的数字证书要放在一个文件中（通常称为“密钥链”(keychain)），如果输入
      keytool -list
那么访问缺省文件，如果没有这个文件，那么就要创建一个，或指定一个已存在的文件。一般为“cacerts”,运行：
      keytool -list -file
缺省位置一般为：
      {java.home}/lib/security/cacerts

3.创建签名

运行：
      keytool -genkey -alias -keystore
这里keyname就是为你的密钥取一个别名，url就放密钥的位置，通常为"cacerts".按提示输入密码等信息。
keytool有很多的运行参数，如-valid就是可以指定密钥的有效天数。

4.查看新建的密钥

运行：
      keytool -list -keystore

5.给自己的jar文件签名

运行：
   jarsigner -keystore
url表示cacerts文件的位置，jarfile是自己的jar文件的名称，keyname是密钥的名称。

6.在网页用使用

现在就有一个jar文件，它标识成是采用自己提供的密钥进行签名的，这样子就能保证在签名之后，这个jar文件没有被篡改过。
不过要确保html文件中的applet标记包含了“archive”属性，来指定jar文件的名称。

         achive=ifpreFileAccessApplet
     width=200
     heigt =100>

重归本垒（Bing） 2006-12-12 09:51 发表评论

Java编程思想第三版摘录(2)分类:JAVA学习资料

重归本垒（Bing） — Mon, 11 Dec 2006 08:29:00 GMT

＝＝＝＝＝＝＝＝

Chap11 对象的集合

1.数组

数组与其它容器的区别体现在三个方面：效率，类型识别，以及可以持有primitives。

数组是Java提供的，能随机存储和访问reference序列的诸多方法中，最高效的一种。速度的代价是，当一个数组创建后，容量就固定了。

创建数组的时候，同时指明了数组元素的类型。而泛型容器类如List，Set和Map等，所持有的对象均被上传为Object。

2.数组是第一流的对象

数组的标识符实际上是一个“创建在堆（heap）里的实实在在的对象的”reference。这个对象持有其它对象的reference，或直接持有primitive类型的值。

3.Arrays类

java.util.Arrays类，包括了一组可用于数组的static方法。其中asList()方法，可把数组转成一个List。

Arrays.fill()方法，把一个值或对象的reference拷贝到数组的各个位置，或指定的范围。

4.复制一个数组

相比for循环，System.arrayCopy()能以更快的速度拷贝数组。如果是对象数组，拷贝的是数组中对象的reference，对象本身不会被拷贝。这被称为浅拷贝(Shallow copy)。

5.数组的比较

Arrays提供了equals()方法。数组是否相等是基于其内容的。

数组要想完全相等，它们必须有相同数量的元素，且数组的每个元素必须与另一个数组的对应位置上的元素相等。

元素的相等性，用equals()判断。对于primitive，会使用其wrapper类的equals()。

6.数组元素的比较

实现比较功能的一个方法是实现java.lang.Comparable接口。这个接口只有一个compareTo()方法。

Arrays.sort()会把传给它的数组的元素转换成Comparable。如果数组元素没有实现Comparable接口，就会引发一个ClassCastException。

实现比较功能的另一个方法使用策略模式(strategy design pattern)，即实现Comparator接口。

Arrays.sort()可接受一个数组和一个Comparator，根据Comparator的compare()方法对数组元素排序。

Java标准类库所用的排序算法已经作了优化－－对于primitive，它用的是快速排序(Quicksort)，对于对象，它用的是稳定合并排序(stable merge sort)。

7.查询有序数组

一旦对数组进行了排序，就能用Arrays.binarySearch()进行快速查询了。但切忌对一个尚未排序的数组使用binarySearch()。

如果Arrays.binarySearch()查找到了，就返回一个大于或等于0的值。否则返回负值。这个负值的意思是，如果手动维护这个数组，这个值应该插在哪个位置。这个值是：

-(插入点)-1

“插入点”就是，在所有比要找的值更大的值中，最小的那个值的下标。如果数组中所有值都比要查找的值小，它就是a.size()。

如果数组里有重复元素，binarySearch()不能保证返回哪一个，但也不报错。

如果排序的时候用到了Comparator，那么调用binarySearch()的时候，也必须使用同一个Comparator。

8.数组部分的总结

如果要持有一组对象，首选，同时效率最高的，应该是数组。如果是要持有一组primitive，也只能用数组。

9.容器简介

Java2的容器类要解决“怎样持有对象”，它把这个问题分成两类：

(1).Collection:通常是一组有一定规律的独立元素。List必须按特定的顺序持有这些元素，而Set不能保存重复的元素。

(2).Map:一组以“键－值”(key-value)形式出现的pair。Map可以返回键(Key)的Set，值的Collection，或者pair的Set。

10.填充容器

Collection也有一个辅助类Collections，它包含了一些静态的使用工具方法，其中有fill()。fill()只是把同一个对象的reference负值到整个容器，而且只能为List，不能为Set和Map工作。并且这个fill()只能替换容器中的值，而不是往List加新元素。如：

List list = new ArrayList();

for(int i = 0; i<10; i++)

list.add("");

Collections.fill(list, "Hello");

11.容器的缺点：不知道对象的类型

Java的容器只持有Object。容器对“能往里面加什么类型的对象”没有限制。在使用容器中的对象之前，还必须进行类型转换

12.迭代器

迭代器(iterator)，又是一个设计模式。iterator能让程序员在不知道或不关心他所处理的是什么样的底层序列结构的情况下，在一个对象序列中前后移动，并选取其中的对象。iterator是“轻量级”的对象，即创建代价很小的对象。

不经意的递归(Unintended recursion)

public class A{

public String toString(){

return "A address:" + this +"\n";//

}

public static void main(String[] args){

System.out.println(new A());

}

上面的程序会出现无穷无尽的异常。

"A address:" + this ，编译器会试着将this转换成String，要用大toString()，于是就变成递归调用了。

如果想打印对象的地址，应该调用Object的toString()方法。而不要用this，应该写super.toString()。

13.List的功能

ArrayList，一个用数组实现的List。能进行快速的随机访问，但是往列表中插入和删除元素比较慢。

LinkedList，对顺序访问进行了优化。在List中插入和删除元素代价也不高。但是随机访问的速度相对较慢。可以把它当成栈(Stack)，队列(queue)或双向队列(deque)来用。

14.Set的功能

加入Set的每个元素必须是唯一的。要想加进Set，Object必须定义equals()，才能标明对象的唯一性。

HashSet，为优化查询速度而设计的Set。要放进HashSet的Object还要定义hashCode()。

TreeSet，一个有序的Set，能从中提取一个有序序列。用了红黑树(red-black tree)数据结构。

LinkedHashSet，使用链表的Set，既有HashSet的查询速度，又能保存元素的插入顺序。用Iterator遍历Set的时候，它是按插入顺序进行访问的。

Set要有一个判断以什么顺序来存储元素的标准，也就是说必须实现Comparable接口，并且定义compareTo()方法。

15.SortedSet

SortedSet(只有TreeSet这一个实现可用)中的元素一定是有序的。SortedSet的意思是“根据对象的比较顺序”，而不是“插入顺序”进行排序。

16.Map的功能

如果知道get()是怎么工作的，就会发觉在ArrayList里面找对象是相当慢的。而这正是HashMap的强项。HashMap利用对象的hashCode()来进行快速查找。

Map的keySet()方法返回一个由Map的键组成的Set。values()返回的是由Map的值所组成的Collection。由于这些Collection的后台都是map，因此对这些Collection的任何修改都会反映到Map上。

17.SortedMap

SortedMap(只有TreeMap这一个实现)的键肯定是有序的。

18.LinkedHashMap

为提高速度，LinkedHashMap对所有东西都作了hash，而且遍历的时候，还会按插入顺序返回pair。此外，还可通过构造函数进行配置，让它使用基于访问的LRU(least-recently-used)算法，这样没被访问过的元素（通常也是要删除的候选对象）就会出现在队列的最前面。

19.散列算法与Hash数

要想用自己的类作HashMap的键，必须覆写equals()和hashCode()。HashMap用equals()来判断查询用的键是否与表里其它键相等。

Object的hashCode()，在缺省情况下就是返回对象的内存地址。

一个合适的equals()必须做到以下五点：

(1).反身性：对任何x，x.equals(x)必须是true。

(2).对称性：对任何x和y，如果y.equals(x)是true的，那么x.equals(y)也必须是true。

(3).传递性：对任何x，y和z，如果x.equals(y)是true，且y.equals(z)也是true，那么x.equals(z)也必须是true。

(4).一致性：对任何x和y，如果对象里面用来判断相等性的信息没有修改过，那么无论调用多少次x.equals(y)，它都必须一致地返回true或false。

(5).对于任何非空的x，x.equals(null)必须返回false。

默认的Object.equals()只是简单地比较两个对象的地址，所以一个Dog("A")会不等于另一个Dog("A")。

下面是覆写equals()和hashCode()的例子。

public class Dog{

public int id;

public Dog(int x){ id = x; }

public int hashCode(){ return id; }

public boolean equals(Object o){

return (o instanceof Dog) && (id == ((Dog)o).id)

}

equals()在利用instanceof检查参数是不是Dog类型的同时，还检查了对象是不是null，如果是null，instanceof会返回false。

20.理解hashCode()

数组是最快的数据结构，所以很容易想到用数组存储Map的键的信息（而不是键本身）。Map要能存储任意数量的pair，而键的数量又被数组的固定大小限制了，所以不能用数组存储键本身。

要解决定长数组的问题，就得允许多个键生成同一个hash数，也就是会有冲突，每个键对象都会对应数组的某个位置。

查找过程从计算hash数开始，算完后用这个数在数组里定位。如果散列函数能确保不产生冲突（如果对象数量是固定的，这是可能的），那么它就被称为“完全散列函数”，这是特例。通常，冲突是由“外部链(external chaining)”处理的：数组并不直接指向对象，而是指向一个对象的列表。然后再用equals()在这个列表中一个个找。如果散列函数定义得好，每个hash数只对应很少的对象，这样，与搜索整个序列相比，能很快跳到这个子序列，比较少量对象，会快许多。

hash表的“槽位”常被称为bucket。

21.影响HashMap性能的因素

Capacity：hash表里bucket的数量。

Initial capacity：创建hash表时，bucket的数量。

Size：当前hash表的记录的数量。

Load factor：size/capacity。一个负载较轻的表会有较少的冲突，因此插入和查找的速度会比较快，但在用迭代器遍历的时候会比较慢。

HashMap和HashSet都提供了能指定load factor的构造函数，当load factor达到这个阀值的时候，容器会自动将capacity(bucket的数量)增加大约一倍，然后将现有的对象分配到新的bucket里面（这就是所谓的rehash）。缺省情况下HashMap会使用0.75的load factor。

22.选择实现

HashTable，Vector和Stack属于老版本遗留下来的类，应该避免使用。

如何挑选List

数组的随机访问和顺序访问比任何容器都快。ArrayList的随机访问比LinkedList快，奇怪的时LinkedList的顺序访问居然比ArrayList略快。LinkedList的插入和删除，特别时删除，比ArrayList快很多。Vector各方面速度都比ArrayList慢，应避免使用。

如何挑选Set

HashSet各项性能都比TreeSet好，只有在需要有序的Set时，才应该用TreeSet。

LinkedHashSet的插入比HashSet稍慢一些，因为要承担维护链表和hash容器的双重代价，但是它的遍历速度比较快。

如何挑选Map

首选HashMap，只有在需要有序map时，才选TreeMap。LinkedHashMap比Hashmap稍慢一些。

23.把Collection和Map设成不可修改的

Collections.unmodifiableCollection()方法，会把传给它的容器变成只读版返回。这个方法有四种变形，unmodifiableCollection(),unmodifiableList(),unmodifiableSet(),unmodifiableMap()。

24.Collection和Map的同步

Collections里有一个自动对容器做同步的方法，它的语法与“unmodifiable”方法有些相似。synchronizedCollection(),synchronizedList(),synchronizedSet(),synchronizedMap()。

25.Fail fast

Java容器类库继承了fail-fast(及早报告错误)机制，它能防止多个进程同时修改容器的内容。当它发现有其它进程在修改容器，就会立即返回一个ConcurrentModificationException。

26.可以不支持的操作

可以用Arrays.asList()把数组改造成List，但它只是部分的实现了Collection和List接口。它支持的都是那些不改变数组容量的操作，不支持add(),addAll(),clear(),retainAll(),remove(),removeAll()等。调用不支持的方法会引发一个UnsupportedOperationException异常。

要想创建普通容器，可以把Arrays.asList()的结果做为构造函数参数传给List或Set，这样就能使用它的完整接口了。

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

Chap12 Java I/O系统

1.File类

File类有一个极具欺骗性的名字，可以用来表示某个文件的名字，也可以用来表示目录里一组文件的名字。

File类的功能不仅限于显示文件或目录。它能创建新的目录，甚至是目录路径。此外还能检查文件的属性，判断File对象表示的是文件还是目录，以及删除文件等。

2.输入与输入

流(Stream)是一种能生成或接受数据的，代表数据的源和目标的对象。流把I/O设备内部的具体操作给隐藏起来了。

Java的I/O类库分成输入和输出两大部分。

3.添加属性与适用的接口

使用“分层对象(layered objects)”，为单个对象动态地，透明地添加功能的做法，被称为Decorator Pattern。Decorator模式要求所有包覆在原始对象之外的对象，都必须具有与之完全相同的接口。无论对象是否被decorate过，传给它的消息总是相同的。

为InputStream和OutputStream定义decorator类接口的类，分别是FilterInputStream和FilterOutputStream，它们都继承自I/O类库的基类InputStream和OutputStream，这是decorator模式的关键（惟有这样，decorator类的接口才能与它要服务的对象的完全相同）。

对于I/O类库来说，比较明智的做法是，普遍都做缓冲，把不缓冲当特例。

Reader和Writer类系

InputStream和OutputStream的某些功能已经淘汰，但仍然提供了很多有价值的，面向byte的I/O功能。而Java 1.1引进的Reader和Writer则提供了Unicode兼容的，面向字符的I/O功能。Java 1.1还提供了两个适配器(adapter)类，InputStreamReader和OutputStreamWriter负载将InputStream和OutputStream转化成Reader和Writer。

Reader和Writer要解决的，最主要是国际化。原先的I/O类库只支持8位的字节流，因此不可能很好地处理16位的Unicode字符流。此外新类库的性能也比旧的好。

4.数据源和目的

几乎所有的Java I/O流都有与之对应的，专门用来处理Unicode的Reader和Writer。但有时，面向byte的InputStream和OutputStream才是正确的选择，特别是java.util.zip，它的类都是面向byte的。

明智的做法是，先用Reader和Writer，等到必须要用面向byte的类库时，你自然会知道，因为程序编译不过去了。

5.常见的I/O流的使用方法

(1).对输入文件做缓冲

BufferedReader in = new BufferedReader( new FileReader("IOStreamDemo.java"));

String s, s2 = new String();

while((s = in.readLine())!= null)

s2 += s + "\n";//readLine()会把换行符剥掉，所以在这里加上。

in.close();

//读取标准输入

BufferedReader stdin = new BufferedReader( new InputStreamReader(System.in));

System.out.print("Enter a line:");

System.out.println(stdin.readLine());

(2).读取内存

StringReader in2 = new StringReader(s2);

int c;

while((c = in2.read())!=-1)//read()会把读出来的byte当做int

System.out.print((char)c);

(3).读取格式化内存

try{

DataInputStream in3 = new DataInputStream(new ByteArrayInputStream(s2.getBytes()));

while(true)

System.out.print((char)in3.readByte());//无法根据readByte()返回值判断是否结束

} catch(EOFException e){

System.err.println("End of stream");

}

//使用available()来判断还有多少字符

DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream("TestEOF.java")));

while(in.available() != 0)

System.out.print((char)in.readByte());

(4).读取文件

try{

BfferedReader in4 = new BufferedReader(new StringReader(s2));

PrintWriter out1 = new PrintWriter(new BufferedWriter(new FileWriter(IODemo.out)));

int lineCount = 1;

while((s = in4.readLine())!= null)

out1.println(lineCount++ +": "+ s);

out1.close();

} catch(EOFException e){

System.err.println(End of stream);

}

使用PrintWriter去排版，就能得出能够读得懂的，普通的文本文件。

6.标准I/O

标准I/O是Unix的概念，意思是，一个程序只使用一个信息流。所有输入都是从“标准输入”进来的，输出都从“标准输出”出去，错误消息都送到“标准错误”里。

Java遵循标准I/O的模型，提供了Syetem.in，System.out，以及System.err。

将System.out转换成PrintWriter

System.out是PrintStream，也就是说它是OutputStream。不过可通过PrintWriter的构造函数把它改造成PrintWriter。

PrintWriter out = new PrintWriter(System.out, true);

out.println("Hello, world");

为了启动自动清空缓冲区的功能，一定要使用双参数版的构造函数，并把第二个参数设成true。这点非常重要，否则就有可能会看不到输出。

标准I/O的重定向

Java的System类提供了几个能重定向标准输入，标准输出和标准错误的静态方法：

setIn(InputStream),setOut(PrintStream),setErr(PrintStream)。

I/O重定向处理的不是character流，而是byte流，因此不能用Reader和Writer，要用InputStream和OutputStream。

7.New I/O

Java 1.4的java.nio.*引入了一个新的I/O类库，其目的就是提高速度。实际上，旧的I/O类库已经用nio重写。

性能的提高源于它用了更贴近操作系统的结构：channel和buffer。

java.nio.ByteBuffer是唯一一个能直接同channel打交道的buffer。它是一个相当底层的类，存储和提取数据的时候，可以选择是以byte形式还是以primitive形式，但它不能存储对象。这是为了有效地映射到绝大多数操作系统上。

新I/O修改了旧I/O的三个类，即FileInputStream，FileOutputStream，以及RandomAccessFile，以获取FileChannel。

// Write a file:

FileChannel fc = new FileOutputStream("data.txt").getChannel();

fc.write(ByteBuffer.wrap("Some text ".getBytes()));

fc.close();

// Add to the end of the file:

fc = new RandomAccessFile("data.txt", "rw").getChannel();

fc.position(fc.size()); // Move to the end

fc.write(ByteBuffer.wrap("Some more".getBytes()));

fc.close();

// Read the file:

fc = new FileInputStream("data.txt").getChannel();

ByteBuffer buff = ByteBuffer.allocate(4096);

fc.read(buff);

buff.flip();

while(buff.hasRemaining())

System.out.print((char)buff.get());

用wrap( )方法把一个已经拿到手的byte数组"包"到ByteBuffer。如果是用这种方法，新创建的ByteBuffer是不会去拷贝底层的(byte)数组的，相反它直接用那个byte数组来当自己的存储空间。所以我们说ByteBuffer的"后台"是数组。

从buffer中取数据前，要调用buffer的flip()。往buffer中装数据前，要调用buffer的clear()。

FileChannel

in = new FileInputStream(args[0]).getChannel(),

out = new FileOutputStream(args[1]).getChannel();

ByteBuffer buffer = ByteBuffer.allocate(BSIZE);

while(in.read(buffer) != -1) {

buffer.flip(); // Prepare for writing

out.write(buffer);

buffer.clear(); // Prepare for reading

}

View Buffers

View Buffer能让你从特殊的视角，来观察其底层的ByteBuffer。对view的任何操作都会作用到ByteBuffer上。同一个ByteBuffer，能读出不同的数据。ByteBuffer以1字节区分数据，CharBuffer是2字节，IntBuffer，FloatBuffer是4字节，LongBuffer和DoubleBuffer是8字节。

ByteBuffer bb = ByteBuffer.wrap(new byte[]{ 0, 0, 0, 0, 0, 0, 0, 'a' });

bb.rewind();

System.out.println("Byte Buffer");

while(bb.hasRemaining())

System.out.println(bb.position()+ " -> " + bb.get());

CharBuffer cb = ((ByteBuffer)bb.rewind()).asCharBuffer();

System.out.println("Char Buffer");

while(cb.hasRemaining())

System.out.println(cb.position()+ " -> " + cb.get());

FloatBuffer fb = ((ByteBuffer)bb.rewind()).asFloatBuffer();

System.out.println("Float Buffer");

while(fb.hasRemaining())

System.out.println(fb.position()+ " -> " + fb.get());

IntBuffer ib = ((ByteBuffer)bb.rewind()).asIntBuffer();

System.out.println("Int Buffer");

while(ib.hasRemaining())

System.out.println(ib.position()+ " -> " + ib.get());

Buffer的细节

如果使用相对定位的get()和put()方法，buffer的position会跟着变化。也可以用下标参数调用绝对定位的get()和put()方法，这时它不会改动buffer的position。

mark()方法会记录当前position，reset()会把position设置到mark的位置。rewind()把position设置到buffer的开头，mark被擦掉了。flip()把limit设为position，把position设为零。当你将数据写入buffer，准备读取的时候，必须先调用这个方法。

内存映射文件

memory-mapped file能让你创建和修改那些大到无法读入内存的文件（最大2GB）。

int length = 0x8FFFFFF; // 128 Mb

MappedByteBuffer out = new RandomAccessFile("test.dat","rw").getChannel().map(FileChannel.MapMode.READ_WRITE,0,length);

for(int i = 0; i < length; i++)

out.put((byte)'x');

for(int i = length/2;i

System.out.print((char)out.get(i));

MappedByteBuffer是ByteBuffer的派生类。例程创建了一个128MB的文件，文件的访问好像只是一瞬间的事，这是因为，真正调入内存的只是其中的一小部分，其余部分则被放在交换文件上。Java是调用操作系统的"文件映射机制(file-mapping facility)"来提升性能的。只有RandomAccessFile才能写映射文件。

文件锁

Java的文件锁是直接映射操作系统的锁机制的，因此其它进程也能看到文件锁。

FileOutputStream fos= new FileOutputStream("file.txt");

FileLock fl = fos.getChannel().tryLock();

if(fl != null) {

System.out.println("Locked File");

Thread.sleep(100);

fl.release();

System.out.println("Released Lock");

}

fos.close();

tryLock( ) 是非阻塞的。它会试着去获取这个锁，但是如果得不到(其它进程已经以独占方式得到这个锁了)，那它就直接返回。而lock( )是阻塞的。如果得不到锁，它会在一直处于阻塞状态，除非它得到了锁，或者你打断了调用它(即lock( )方法)的线程，或者关闭了它要lock( )的channel，否则它是不会返回的。最后用FileLock.release( )释放锁。

还可以像这样锁住文件的某一部分，

tryLock(long position, long size, boolean shared)

或者

lock(long position, long size, boolean shared)

这个方法能锁住文件的某个区域(size - position)。其中第三个参数表示锁能不能共享。

对于带参数的lock( )和tryLock( )方法，如果你锁住了position到position+size这段范围，而文件的长度又增加了，那么position+size后面是不加锁的。而无参数的lock方法则会锁定整个文件，不管它变不变长。

8.压缩

Java I/O类库还收录了一些能读写压缩格式流的类，它们是InputStream和OutputStream的派生类。这是因为压缩算法是针对byte而不是字符的。

GZIP的接口比较简单，因此如果你只有一个流要压缩的话，用它会比较合适。

BufferedReader in = new BufferedReader(new FileReader(args[0]));

BufferedOutputStream out = new BufferedOutputStream(

new GZIPOutputStream(new FileOutputStream("test.gz")));

System.out.println("Writing file");

int c;

while((c = in.read()) != -1)

out.write(c);

in.close();

out.close();

System.out.println("Reading file");

BufferedReader in2 = new BufferedReader(

new InputStreamReader(new GZIPInputStream(new FileInputStream("test.gz"))));

String s;

while((s = in2.readLine()) != null)

System.out.println(s);

只要用GZIPOutputStream 或ZipOutputStream把输出流包起来，再用GZIPInputStream 或ZipInputStream把输入流包起来就行了。

用Zip存储多个文件

FileOutputStream f = new FileOutputStream("test.zip");

CheckedOutputStream csum = new CheckedOutputStream(f, new Adler32());

ZipOutputStream zos = new ZipOutputStream(csum);

BufferedOutputStream out = new BufferedOutputStream(zos);

zos.setComment("A test of Java Zipping");

// No corresponding getComment(), though.

for(int i = 0; i < args.length; i++) {

System.out.println("Writing file " + args[i]);

BufferedReader in = new BufferedReader(new FileReader(args[i]));

zos.putNextEntry(new ZipEntry(args[i]));

int c;

while((c = in.read()) != -1)

out.write(c);

in.close();

}

out.close();

// Checksum valid only after the file has been closed!

System.out.println("Checksum: " + csum.getChecksum().getValue());

// Now extract the files:

System.out.println("Reading file");

FileInputStream fi = new FileInputStream("test.zip");

CheckedInputStream csumi = new CheckedInputStream(fi, new Adler32());

ZipInputStream in2 = new ZipInputStream(csumi);

BufferedInputStream bis = new BufferedInputStream(in2);

ZipEntry ze;

while((ze = in2.getNextEntry()) != null) {

System.out.println("Reading file " + ze);

int x;

while((x = bis.read()) != -1)

System.out.write(x);

}

System.out.println("Checksum: " + csumi.getChecksum().getValue());

bis.close();

// Alternative way to open and read zip files:

ZipFile zf = new ZipFile("test.zip");

Enumeration e = zf.entries();

while(e.hasMoreElements()) {

ZipEntry ze2 = (ZipEntry)e.nextElement();

System.out.println("File: " + ze2);

// ... and extract the data as before

}

虽然标准的Zip格式是支持口令的，但是Java的Zip类库却不支持。

Java ARchives (JARs)

一个JAR只有一个文件，包含两个文件，一个是Zip文件，另一个是描述Zip文件所包含的文件的"manifest(清单)"。

如果JAR是用0(零)选项创建的，不会进行压缩，那么它就能被列入CLASSPATH了。

不能往已经做好的JAR里添加新文件或修改文件。不能在往JAR里移文件的同时把原来的文件给删了。不过JAR格式是跨平台的，无论JAR是在哪个平台上创建的，jar程序都能将它读出来(zip格式有时就会有问题了)。

9.对象的序列化

Java的"对象序列化"能让你将一个实现了Serializable接口的对象转换成一组byte，需要的时候，根据byte数据重新构建那个对象。这一点甚至在跨网络的环境下也是如此，序列化机制能自动补偿操作系统方面的差异。

对象序列化不仅能保存对象的副本，而且还会跟着对象里面的reference，把它所引用的对象也保存起来，然后再继续跟踪那些对象的reference，以此类推。这种情形常被称为"单个对象所联结的'对象网'"。这个机制所涵盖的范围不仅包括对象的成员数据，而且还包含数组里面的reference。

Worm w = new Worm(6, 'a');

ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("worm.out"));

out.writeObject("Worm storage\n");

out.writeObject(w);

out.close(); // Also flushes output

ObjectInputStream in = new ObjectInputStream(new FileInputStream("worm.out"));

String s = (String)in.readObject();

Worm w2 = (Worm)in.readObject();

把对象从序列化状态中恢复出来的必要条件是，一定要让JVM找到.class文件。

控制序列化

可以让对象去实现Externalizable而不是Serializable接口，并以此来控制序列化的过程。

对于Externalizable对象，readExternal( )要在默认的构造行为会发生之后(包括在定义数据成员时进行的初始化)才启动。

不但要在writeExternal( )的时候把重要的数据保存起来(默认情况下，Externalizable对象不会保存任何成员对象)，还得在readExternal( )的时候把它们恢复出来。为了能正确地存取其父类的组件，你还得调用其父类的writeExternal( )和readExternal( )。

transient关键词

要想禁止敏感信息的序列化，除了可以实现Externalizable外。还可以使用transient关键词修饰Serializable对象中不想序列化的成员。

默认情况下，Externalizable对象不保存任何字段，因此transient只能用于Serializable对象。

Externalizable的替代方案

如果你不喜欢Externalizable，还可以选择Serializable接口，然后再加入(注意，我没说"覆写"或"实现")序列化和恢复的时候会自动调用的writeObject( )和readObject( )方法。也就是说，如果你写了这两个方法，Java就会避开默认的序列化机制而去调用这两个方法了。

两个方法的特征签名如下，（它们都是private的，怪异）：

private void writeObject(ObjectOutputStream stream) throws IOException;

private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException

如果你决定用默认的序列化机制来存储非transient的数据，你就得在writeObject( )里面调用defaultWriteObject( )，不带参数，而且得第一个做。恢复的时候，也要在readObject( )的开头部分调用defaultReadObject( )。

如果你要序列化static数据，就必须亲自动手。

Preferences

JDK 1.4所引入的Preferences API能自动存储和恢复信息。但是，它只能存取很少几种数据——primitive和String，而且每个String的长度都不能超过8K。

Preferences是一组存储在"由节点所组成的层次体系(a hierarchy of nodes)"里的键值集(很像Map)。Preferences API是借用操作系统的资源来实现功能的。对于Windows，它就放在注册表里。

//也可以用systemNodeForPackage( )

//"user"指的是单个用户的preference，而"system"指整个系统的共用配置

//一般用XXX.class做节点的标识符

Preferences prefs = Preferences.userNodeForPackage(PreferencesDemo.class);

prefs.put("Location", "Oz");

prefs.putInt("Companions", 4);

prefs.putBoolean("Are there witches?", true);

10.正则表达式

正则表达式是JDK 1.4的新功能。由java.util.regex的Pattern和Matcher类实现的。

Pattern p = Pattern.compile(("\\w+");

Matcher m = p.matcher(args[0]);

while(m.find()) {

System.out.println("Match \"" + m.group() +

"\" at positions " +

m.start() + "-" + (m.end() - 1));

}

只要字符串里有这个模式，find( )就能把它给找出来，但是matches( )成功的前提是正则表达式与字符串完全匹配，而lookingAt( )成功的前提是，字符串的开始部分与正则表达式相匹配。

split()

所谓分割是指将以正则表达式为界，将字符串分割成String数组。

String[] split(CharSequence charseq)

String[] split(CharSequence charseq, int limit)//限定分割的次数

String input = "This!!unusual use!!of exclamation!!points";

System.out.println(Arrays.asList(Pattern.compile("!!").split(input)));

＝＝＝＝＝＝＝＝＝＝＝

Chap13 并发编程

1.基本线程

要想创建线程，最简单的办法就是继承java.lang.Thread。run( )是Thread最重要的方法，什么时候run( )返回了，线程也就中止了。

Thread的start( )方法会先对线程做一些初始化，再调用run( )。

整个步骤应该是：调用构造函数创建一个Thread对象，并且在构造函数里面调用start( )来配置这个线程，然后让线程的执行机制去调用run( )。如果你不调用start( )，那么线程永远也不会启动。

有时我们创建了Thread，但是却没去拿它的reference。如果是普通对象，这一点就足以让它成为垃圾，但Thread不会。Thread都会为它自己"注册"，所以实际上reference还保留在某个地方。除非run( )退出，线程中止，否则垃圾回收器不能动它。

线程的调度机制是非决定性，即多个线程的执行顺序是不确定的。

yielding

如果知道run()已经告一段落了，你就可以用yield( )形式给线程调度机制作一个暗示。Java的线程调度机制是抢占式的(preemptive)，只要它认为有必要，它会随时中断当前线程（运行到yield之前），并且切换到其它线程。总之，yield( )只会在很少的情况下起作用。

Sleeping

sleep( )一定要放在try域里，这是因为有可能会出现时间没到sleep( )就被中断的情况。如果有人拿到了线程的reference，并且调用了它的interrupt( )，这种事就发生了。(interrupt( )也会影响处于wait( )或join( )状态的线程，所以这两个方法也要放在try域里。)如果你准备用interrupt( )唤醒线程，那最好是用wait( )而不是sleep( )，因为这两者的catch语句是不一样的。

优先级

线程往控制台打印的时候是不会被中断的，否则控制台的显示就乱了。

守护线程

所谓"守护线程(daemon thread)"是指，只要程序还在运行，它就应该在后台提供某种公共服务的线程，但是守护线程不属于程序的核心部分。因此，当所有非守护线程都运行结束的时候，程序也结束了。

要想创建守护线程，必须在它启动之前就setDaemon(true)。守护线程所创建的线程也自动是守护线程。

连接线程

线程还能调用另一个线程的join( )，等那个线程结束之后再继续运行。如果线程调用了另一个线程t的t.join( )，那么在线程t结束之前(判断标准是，t.isAlive( )等于false)，主叫线程会被挂起。

另一种方式：Runable

类可能已经继承了别的类，这时就需要实现Runable接口了。

如果要在这个实现了Runable的类里做Thread对象才有的操作，必须用Thread.currentThread()获取其reference。

除非迫不得已只能用Runnable，否则选Thread。

2.共享有限的资源

多线程环境的最本质的问题：永远也不会知道线程会在什么时候启动。

我们不能从线程内部往外面抛异常，因为这只会中止线程而不是程序。

资源访问的冲突

Semaphore是一种用于线程间通信的标志对象。如果semaphore的值是零，则线程可以获得它所监视的资源，如果不是零，那么线程就必须等待。如果申请到了资源，线程会先对semaphore作递增，再使用这个资源。递增和递减是原子操作(atomic operation，也就是说不会被打断的操作)，由此semaphore就防止两个线程同时使用同一项资源。

解决共享资源的冲突

一个特定的对象中的所有的synchronized方法都会共享一个锁，而这个锁能防止两个或两个以上线程同时读写一块共用内存。当你调用synchronized方法时，这个对象就被锁住了。在方法返回并且解锁之前，谁也不能调用同一个对象的其它synchronized方法。

一定要记住：所有访问共享资源的方法都必须是synchronized的，否则程序肯定会出错。

一个线程能多次获得对象的锁。比如，一个synchronized方法调用了另一个synchronized方法，而后者又调用了另一synchronized方法。线程每获一次对象的锁，计数器就加一。当然，只有第一次获得对象锁的线程才能多次获得锁。线程每退出一个synchronized方法，计数器就减一。等减到零了，对象也就解锁了。

此外每个类还有一个锁(它属于类的Class对象)，这样当类的synchronized static方法读取static数据的时候，就不会相互干扰了。

原子操作

通常所说的原子操作包括对非long和double型的primitive进行赋值，以及返回这两者之外的primitive。不过如果你在long或double前面加了volatile，那么它就肯定是原子操作了。最安全的原子操作只有读取和对primitive赋值这两种。

如果你要用synchronized修饰类的一个方法，索性把所有的方法全都synchronize了。要判断，哪个方法该不该synchronize，通常是很难的，而且也没什么把握。

并发编程的最高法则：绝对不能想当然。

关键段

有时你只需要防止多个线程同时访问方法中的某一部分，而不是整个方法。这种需要隔离的代码就被称为关键段(critical section)。创建关键段需要用到synchronized关键词，指明执行下列代码需获得哪个对象的锁。

synchronized(syncObject) {

// This code can be accessed by only one thread at a time

}

关键段又被称为"同步块(synchronized block)"。相比同步整个方法，同步一段代码能显著增加其它线程获得这个对象的机会。

3.线程的状态

线程的状态可归纳为以下四种：

(1).new: 线程对象已经创建完毕，但尚未启动(start)，因此还不能运行。

(2).Runnable: 处在这种状态下的线程，只要分时机制分配给它CPU周期，它就能运行。

(3).Dead: 要想中止线程，正常的做法是退出run( )。

(4).Blocked: 就线程本身而言，它是可以运行的，但是有什么别的原因在阻止它运行。线程调度机制会直接跳过blocked的线程，根本不给它分配CPU的时间。除非它重新进入runnable状态，否则什么都干不了。

如果线程被阻塞了，那肯定是出了什么问题。问题可能有以下几种：

(1).你用sleep(milliseconds)方法叫线程休眠。在此期间，线程是不能运行的。

(2).你用wait( )方法把线程挂了起来。除非收到notify( )或notifyAll( )消息，否则线程无法重新进入runnable状态。

(3).线程在等I/O结束。

(4).线程要调用另一个对象的synchronized方法，但是还没有得到对象的锁。

4.线程间的协作

wait与notify

线程sleep( )的时候并不释放对象的锁，但是wait( )的时候却会释放对象的锁。也就是说在线程wait( )期间，别的线程可以调用它的synchronized方法。此外，sleep( )属于Thread。wait( )， notify( )，和notifyAll( )是根Object的方法。

只能在synchronized方法里或synchronized段里调用wait( )，notify( )或notifyAll( )。

wait( )能让你在等待条件改变的同时让线程休眠，当其他线程调用了对象的notify( )或notifyAll( )的时候，线程自会醒来，然后检查条件是不是改变了。

安全的做法就是套用下面这个wait( )定式:

while(conditionIsNotMet)

wait( );

用管道进行线程间的I/O操作

在很多情况下，线程也可以利用I/O来进行通信。对Java I/O类库而言，就是PipedWriter(可以让线程往管道里写数据)和PipedReader(让另一个线程从这个管道里读数据)。

5.死锁

Dijkstra发现的经典的死锁场景：哲学家吃饭问题。

只有在下述四个条件同时满足的情况下，死锁才会发生:

(1).互斥：也许线程会用到很多资源，但其中至少要有一项是不能共享的(同一时刻只能被一个线程访问)。

(2).至少要有一个进程会在占用一项资源的同时还在等另一项正被其它进程所占用的资源。也就是说，要想让死锁发生，哲学家必须攥着一根筷子等另一根。

(3).(调度系统或其他进程)不能从进程里抢资源。所有进程都必须正常的释放资源。我们的哲学家都彬彬有礼，不会从他的邻座手里抢筷子。

(4).需要有等待的环。一个进程在等一个已经被另一进程抢占了的资源，而那个进程又在等另一个被第三个进程抢占了的资源，以此类推，直到有个进程正在等被第一个进程抢占了的资源，这样就形成了瘫痪性的阻塞了。这里，由于每个哲学家都是先左后右的拿筷子，所以有可能会造成等待的环。在例程中，我们修改了最后一位哲学家的构造函数，让他先右后左地拿筷子，从而破解了死锁。

Java语言没有提供任何能预防死锁的机制。

6.停止线程的正确的方法

为了降低死锁的发生几率，Java 2放弃了Thread类stop( )，suspend( )和resume( )方法。

应该设置一个旗标(flag)来告诉线程什么时候该停止。

7.打断受阻的线程

有时线程受阻之后就不能再做轮询了，比如在等输入，这时你就不能像前面那样去查询旗标了。碰到这种情况，你可以用Thread.interrupt( )方法打断受阻的线程。最后要把受阻线程的 reference设成null。

8.总结

诺贝尔经济学奖得主Joseph Stiglitz有一条人生哲学，就是所谓的承诺升级理论:

"延续错误的代价是别人付的，但是承认错误的代价是由你付的。"

多线程的主要缺点包括:

(1).等待共享资源的时候，运行速度会慢下来。

(2).线程管理需要额外的CPU开销。

(3).如果设计得不不合理，程序会变得异常复杂。

(4).会引发一些不正常的状态，像饥饿(starving)，竞争(racing)，死锁(deadlock)，活锁(livelock)。

(5).不同平台上会有一些不一致。

通常你可以在run( )的主循环里插上yield( )，然后让线程调度机制帮你加快程序的运行。

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

Chap14 创建Windows与Applet程序

设计中一条基本原则：让简单的事情变得容易，让困难的事情变得可行。

软件工业界的“三次修订”规则：产品在修订三次后才会成熟。

1.控制布局

在Java中，组件放置在窗体上的方式可能与其他GUI系统都不相同。首先，它完全基于代码，没有用来控制组件布局的“资源”。第二，组件的位置不是通过绝对坐标控制，二十由“布局管理器”(layout manager)根据组件加入的顺序决定其位置。使用不同的布局管理器，组件的大小、形状和位置将大不相同。此外，布局管理器还可以适应applet或视窗的大小，调整组件的布局。

JApplet,JFrame,JWindow和JDialog都可以通过getContentPane()得到一个容器(Container)，用来包含和显示组件。容器有setLayout()方法，用来设置布局管理器。

2.Swing事件模型

在Swing的事件模型中，组件可以触发一个事件。每种事件的类型由单独的类表示。当事件被触发时，它将被一个或多个监听器接收，监听器负责处理事件。

所谓事件监听器，就是一个“实现了某种类型的监听器接口的”类的对象。程序员要做的就是，先创建一个监听器对象，然后把它注册给触发事件的组件。注册动作是通过该组件的addXXXListener()方法完成的。

所有Swing组件都具有addXXXListener()和removeXXXListener()方法。

3.Swing组件一览

工具提示ToolTip

任何JComponent子类对象都可以调用setToolTipText(String)。

Swing组件上的HTML

任何能接受文本的组件都可以接受HTML文本，且能根据HTML格式化文本。例如，

JButton b = new JButton("Hello
Press me");

       必须以""标记开始，但不会强制添加结束标记。

       对于JApplet，在除init()之外的地方添加新组件后，必须调用容器的validate()来强制对组件进行重新布局，才能显示新添加的组件。



       4.选择外观(Look & Feel)

       “可插拔外观”(Pluggable Look & Feel)使你的程序能够模仿不同操作系统的外观。

       设置外观的代码要在创建任何可视组件之前调用。Swing的跨平台的金属外观是默认外观。

       try{

              UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

       } catch(Exception e){

       }

       catch子句中什么也不用做，因为缺省情况下，如果设置外观失败，UIManager将设置成跨平台的外观。



       动态绑定事件

       不能保证事件监听器被调用的顺序与它们被添加的顺序相同。



       5.Swing与并发

       始终存在着一个Swing事件调度线程，它用来依次对Swing的所有事件进行调度。



       管理并发

       当你在类的main()方法中，或在一个独立线程中，准备修改任何Swing组件属性的时候，要注意，Swing的事件调度线程可能会与你竞争同一资源。

       要解决这个问题，必须确保在任何情况下，只能在事件调度线程里修改Swing组件的属性。Swing提供了两种机制：SwingUtilities.invokeLater(Runnable)和SwingUtilities.invokeAndWait(Runnable)。它们都接受runnable对象作参数，并且在Swing的事件处理线程中，只有当事件队列中的任何未处理的事件都被处理完毕之后，它们才会调用runnable对象的run()方法。

       SwingUtilities.invokeLater(new Runnable(){

              public void run(){

                     txt.setText("ready");

              }

       });

       invokeLater()是异步方法，会立即返回。invokeAndWait()是同步方法，会一直阻塞，直到事件处理完毕才会放回。



       6.JavaBean与同步

       当你创建Bean的时候，你必须要假设它可能会在多线程环境下运行。也就是说：

       (1).尽可能让Beand中的所有公共方法都是synchronized。这将导致synchronized的运行时开销。

       (2).当一个多路事件触发了一组对该事件感兴趣的监听器时，必须假定，在遍历列表进行通知的同时，监听器可能会被添加或移除。

       public void notifyListeners(){

              ActionEvent a = new ActionEvent(BangBean2.this, ActionEvent.ACTION_PERFORMED, null);

              ArrayList lv = null;

              //Make a shallow copy of the List in case someone adds a listener while we're

              //calling listeners

              synchronized(this){

                     lv = (ArrayList)actinListeners.clone();

              }

              for(int i = 0; i < lv.size(); i++){

                     ((ActionListener)lv.get(i)).actionPerformed(a);

              }

       }









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

Chap15 发现问题

       1.单元测试

       //Discover the name of the class this object was created within:

       className = new Throwable().getStackTrace()[1].getClassName();



       JUnit

       JUnit在输出消息中使用"."表示每个测试的开始。

       JUnit为每个测试创建一个测试对象（继承自TestCase），以确保在测试运行之间没有不利的影响。所有的测试对象都是同时被创建的，而不是正好在测试方法执行之前才创建。

       setUp是在每个测试方法运行之前被调用的。



       2.利用断言提高可靠性

       断言语法

       assert boolean-expression;

       assert boolean-expression: information-expression;



       在JDK 1.4中，缺省情况下断言是关闭的。为了防止编译时的错误，必须带下面的标志进行编译：

       -source 1.4

       如：javac -source 1.4 Assert1.java



       运行程序也必须加上标志-ea，全拼是-enableassertions。这样才会执行所有的断言语句。



       我们也可以基于类名或包名来决定打开或关闭断言。

       还有另一种动态控制断言的方法：通过ClassLoader对象的方法setDefaultAssertionStatus()，它为所有随后载入的类设置断言的状态。

       public static void main(String[] args){

              ClassLoader.getSystemClassLoader().setDefaultAssertionStatus(true);

              //other statements

       }

       这样可以在运行时，不必使用-ea标志，但是仍然必须使用-source 1.4标志编译。



       为DBC使用断言



       DBC(Design by Contract)是由Bertrand Meyer(Eiffel编程语言的创建者)所阐明的一个概念，它通过确保对象遵循特定的、不能被编译时的类型检查所验证的规则，来帮助建立健壮的程序。



       3.剖析和优化

       “我们应该忽略较小的效率，在97%的时间里我们都应该说：不成熟的优化是万恶之源。”－－Donald Knuth



       最优化指南

       避免为性能而牺牲代码的可读性。

       不能孤立地考虑性能。要权衡所需付出的努力与能得到的利益之间的关系。

       性能是大型工程要关心的问题，但通常不是小型工程要考虑的。

       使程序可运转比钻研程序的性能有更高的优先权。仅当性能被确定是一个关键因素的时候，在初始设计开发过程期间才应该予以考虑。

       不要假设瓶颈在什么地方，而应该运行剖析器来获得数据。

       在任何可能的情况下，尽量通过将对象设置为null，从而显式地将其销毁。有时这可能是对垃圾回收器的一种很有帮助的提示。

       程序大小的问题。仅当程序是大型的、运行时间长而且速度也是一个问题时，性能优化才有价值。

       static final变量可以通过JVM进行优化以提高程序的速度。



       做可以运转的最简单的事物。（极限编程）



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

附录A：对象的传递与返回

       确切地说，Java有指针。Java中（除了基本类型）每个对象的标识符就是一个指针。但是它们受到了限制，有编译器和运行期系统监视着它们。Java有指针，但没有指针的相关算法。可以将它们看作“安全的指针”。

       “别名效应”是指，多个引用指向同一个对象。将引用作为方法的参数传递时，它会自动被别名化。



       制作局部拷贝

       Java中所有的参数传递，执行的都是引用传递。当你传递对象时，真正传递的只是一个引用，指向存活于方法外的“对象”。对此引用做的任何修改，都是在修改方法外的对象。此外：

       (1).别名效应在参数传递时自动发生。

       (2).方法内没有局部对象，只有局部引用。

       (3).引用有作用域，对象则没有。

       (4).在Java中，不需要为对象的生命周期操心。

       (5).没有提供语言级别的支持（例如“常量”）以阻止对象被修改，或者消除别名效应的负面影响。不能简单地使用final关键字来修饰参数，它只能阻止你将当前引用指向其他对象。



       克隆对象

       如果确实要在方法调用中修改参数，但又不希望修改外部参数，那么就应该在方法内部制作一份参数的副本，以保护原参数。

       Object类提供了protected方法clone()，要使用它，必须在子类中以public方式重载此方法。例如，ArrayList就重载了clone()。ArrayList的clone()方法，并不自动克隆容器中包含的每个对象，只是将原ArrayList中的对象别名化，即只复制了ArrayList中对象的引用。这称为浅拷贝（shallow copy）。



       使类具有克隆能力

       虽然在所有类的基类Object中定义了克隆方法，但也不是每个类都自动具有克隆能力。

       克隆对象时有两个关键问题：

       (1).调用super.clone()

       (2).将子类的clone()方法声明为public

       基类的clone()方法，能“逐位复制(bitwise copy)”对象。



       实现Cloneable接口

       interface Cloneable{}

       这样的空接口称为“标记接口(tagging interface)”。

       Cloneable接口的存在有两个理由。第一，如果某个引用上传为基类后，就不知道它是否能克隆。此时，可以用instanceof检查该引用是否指向一个可克隆的对象。

       if(myref instanceof Cloneable)//...

       第二，与克隆能力的设计有关，考虑到也许你不愿意所有类型的对象都是可克隆的。所以Object.clone()会检查当前类是否实现了Cloneable接口，如果没有，就抛出CloneNotSupportedException异常。所以，作为实现克隆能力的一部分，通常必须实现Cloneable接口。



       ==与!=

       Java比较对象相等的等价测试并未深入对象的内部。==和!=只是简单地比较引用。如果引用代表的内存地址相同，则它们指向同一个对象，因此视为相等。所以，该操作符测试的是：不同的引用是否是同一个对象的别名。



       Object.clone()的效果

       克隆过程的第一步通常都是调用super.clone()。它制作出完全相同的副本，为克隆操作建立了基础。在此基础上，你可以执行对完成克隆必要的其他操作。

       这里的其他操作是指，对对象中的每个引用，都明确地调用clone()。否则，那些引用会被别名化，仍指向原本的对象。

       只要没有向子类中添加需要克隆的引用，那么无论clone()定义于继承层次中多深的位置，只需要调用Object.clone()一次，就能完成所有必要的复制。

       对ArrayList深层拷贝而言，以下操作是必须的：克隆ArrayList之后，必须遍历ArrayList中的每个对象，逐一克隆。对HashMap做深层拷贝，也必须做类似的操作。



       向继承体系的更下层增加克隆能力

       可以向任意层次的子类添加克隆能力，从那层以下的子类，也就都具备了克隆能力。



       克隆小结

       如果希望一个类可以被克隆：

       (1).实现Cloneable接口。

       (2).重载clone()，声明为public。

       (3).在clone()中调用Super.clone()。

       (4).在clone()中捕获异常。



       只读类

       在只读类中所有数据都是private的，并且没有定义会修改对象内部状态的方法。只读类的对象可以有很多别名，也不会造成伤害。例如，Java标准类库中所有基本类型的包装类。



       恒常性(immutability)的缺点

       当你需要一个被修改过的此类的对象的时候，必须承受创建新对象的开销，也会更频繁地引发垃圾回收。对于有些类（如String），其代价让人不得不禁止这么做。

       解决之道是创建一个可被修改的伴随类（companion class）。



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

附录B：Java编程指南

       设计

       1.优雅设计终将得到回报。精心设计程序的时候生产率不会很高，但欲速则不达。

       2.先能运行，再求快速。

       3.分而治之。

       4.尽量让所有东西自动化。（如测试和构建，先写测试，再编写类）

       5.尽可能使类原子化。

       建议重新设计类的线索有：

       (1).复杂的switch语句，请考虑使用多态。

       (2).有许多方法，处理类型极为不同的操作：请考虑划分成不同的类。

       (3).有许多成员变量，表示类型极为不同的属性：请考虑划分成不同的类。

       (4).参考《Refactoring:Improving the Design of Existing Code》，Martin Fowler著，(Addison-Wesley 1999)。

       6.将变动的和不变的因素分离。

       7.在判断应该使用继承还是组合的时候，考虑是否需要上传为基类。



       实现

       1.编写通用性的类时，请遵守标准形式。包括定义equals()、hashCode()、toString()、clone()（实现Cloneable接口，或者选择其它对象复制策略），并实现Comparable和Serialiable接口。

       2.在构造器中只做必要的动作：将对象设定为正确的状态。避免在构造器内调用其它方法（final方法除外），因为这些方法可能会被其他人重载，这就可能在构造期间得到意外的结果。

       3.优先选择接口而不是抽象类。只有在必须放进方法定义或成员变量时，才把它改为抽象类。接口只和客户希望的动作有关，而类则倾向于实现细节。

重归本垒（Bing） 2006-12-11 16:29 发表评论

java创建文件夹，文件；删除文件夹，文件

重归本垒（Bing） — Tue, 28 Nov 2006 02:19:00 GMT
     摘要: package ifpre.web; import gxdmif.GXStringUtil; import java.io.DataOutputStream; import java.io.File; import java.io.FileOutputStream; import ...  阅读全文

重归本垒（Bing） 2006-11-28 10:19 发表评论

写Class注意，类的导入一定要正确

重归本垒（Bing） — Wed, 25 Oct 2006 04:55:00 GMT
在写class时，往往要import一些类或包（在不同的包中可能会有名字相同的类），一定要注意的是导入的一定要是自己需要的。
如果导入错误，那么编辑时可能会成功的，运行也可能会没有问题，但就是出不了正确的结果。
例如在写文件上传时我碰到了这个问题，折磨了我两天，多方查资料都没用。
class someclass extends SimpleFormController{
     protected ModelAndView onSubmit(HttpServletRequest req,
            HttpServletResponse response,
            Object command,
            BindException errors)
     throws Exception{
         return null;
   }

}

在导入时我导入了 java.net.BindException;在编辑和运行都没有错，后来我才发现他运行的是super.onSubmit。跟本就没有运行someclass.onSubmit。
而实际上应该是org.springframework.validation.BindException;

同时还要小心的是，如果父类中的方法是什么权限，那么子类的方法不能去扩大这个权限。

重归本垒（Bing） 2006-10-25 12:55 发表评论

设计模式之状态模式的实践

重归本垒（Bing） — Thu, 21 Sep 2006 09:02:00 GMT
     摘要: package state; import context.Context; public class DesignTemplateState implements State {     public ...  阅读全文

重归本垒（Bing） 2006-09-21 17:02 发表评论

JavaMail API详解

重归本垒（Bing） — Thu, 20 Jul 2006 01:24:00 GMT

摘要:
JavaMail API是读取、撰写、发送电子信息的可选包。我们可用它来建立如Eudora、Foxmail、MS Outlook Express一般的邮件用户代理程序（Mail User Agent,简称MUA）。让我们看看JavaMail API是如何提供信息访问功能的吧！JavaMail API被设计用于以不依赖协议的方式去发送和接收电子信息，文中着重：如何以不依赖于协议的方式发送接收电子信息，这也是本文所要描述的.

版权声明：本文可以自由转载，转载时请务必以超链接形式标明文章原始出处和作者信息及本声明
作者:cleverpig(作者的Blog:http://blog.matrix.org.cn/page/cleverpig)
原文:http://www.matrix.org.cn/resource/article/44/44101_JavaMail.html
关键字:java,mail,pop,smtp

一、JavaMail API简介
JavaMail API是读取、撰写、发送电子信息的可选包。我们可用它来建立如Eudora、Foxmail、MS Outlook Express一般的邮件用户代理程序（Mail User Agent,简称MUA）。而不是像sendmail或者其它的邮件传输代理（Mail Transfer Agent，简称MTA）程序那样可以传送、递送、转发邮件。从另外一个角度来看，我们这些电子邮件用户日常用MUA程序来读写邮件，而MUA依赖着MTA处理邮件的递送。
在清楚了到MUA与MTA之间的关系后，让我们看看JavaMail API是如何提供信息访问功能的吧！JavaMail API被设计用于以不依赖协议的方式去发送和接收电子信息，这个API被分为两大部分：

基本功能：如何以不依赖于协议的方式发送接收电子信息，这也是本文所要描述的，不过在下文中，大家将看到这只是一厢情愿而已。
第二个部分则是依赖特定协议的，比如SMTP、POP、IMAP、NNTP协议。在这部分的JavaMail API是为了和服务器通讯，并不在本文的内容中。

二、相关协议一览
在我们步入JavaMail API之前，先看一下API所涉及的协议。以下便是大家日常所知、所乐于使用的4大信息传输协议：
SMTP
POP
IMAP
MIME
当然，上面的4个协议，并不是全部，还有NNTP和其它一些协议可用于传输信息，但是由于不常用到，所以本文便不提及了。理解这4个基本的协议有助于我们更好的使用JavaMail API。然而JavaMail API是被设计为与协议无关的，目前我们并不能克服这些协议的束缚。确切的说，如果我们使用的功能并不被我们选择的协议支持，那么JavaMail API并不可能如魔术师一样神奇的赋予我们这种能力。

1．SMTP
简单邮件传输协议定义了递送邮件的机制。在下文中，我们将使用基于Java-Mail的程序与公司或者ISP的SMTP服务器进行通讯。这个SMTP服务器将邮件转发到接收者的SMTP服务器，直至最后被接收者通过POP或者IMAP协议获取。这并不需要SMTP服务器使用支持授权的邮件转发，但是却的确要注意SMTP服务器的正确设置（SMTP服务器的设置与JavaMail API无关）。

2．POP
POP是一种邮局协议，目前为第3个版本，即众所周知的POP3。POP定义了一种用户如何获得邮件的机制。它规定了每个用户使用一个单独的邮箱。大多数人在使用POP时所熟悉的功能并非都被支持，例如查看邮箱中的新邮件数量。而这个功能是微软的Outlook内建的，那么就说明微软Outlook之类的邮件客户端软件是通过查询最近收到的邮件来计算新邮件的数量来实现前面所说的功能。因此在我们使用JavaMail API时需要注意，当需要获得如前面所讲的新邮件数量之类的信息时，我们不得不自己进行计算。

3．IMAP
IMAP使用在接收信息的高级协议，目前版本为第4版，所以也被称为IMAP4。需要注意的是在使用IMAP时，邮件服务器必须支持该协议。从这个方面讲，我们并不能完全使用IMAP来替代POP，不能期待IMAP在任何地方都被支持。假如邮件服务器支持IMAP，那么我们的邮件程序将能够具有以下被IMAP所支持的特性：每个用户在服务器上可具有多个目录，这些目录能在多个用户之间共享。
其与POP相比高级之处显而易见，但是在尝试采取IMAP时，我们认识到它并不是十分完美的：由于IMAP需要从其它服务器上接收新信息，将这些信息递送给用户，维护每个用户的多个目录，这都为邮件服务器带来了高负载。并且IMAP与POP的一个不同之处是POP用户在接收邮件时将从邮件服务器上下载邮件，而IMAP允许用户直接访问邮件目录，所以在邮件服务器进行备份作业时，由于每个长期使用此邮件系统的用户所用的邮件目录会占有很大的空间，这将直接导致邮件服务器上磁盘空间暴涨。

4．MIME
MIME并不是用于传送邮件的协议，它作为多用途邮件的扩展定义了邮件内容的格式：信息格式、附件格式等等。一些RFC标准都涉及了MIME：RFC 822, RFC 2045, RFC 2046, RFC 2047，有兴趣的Matrixer可以阅读一下。而作为JavaMail API的开发者，我们并不需关心这些格式定义，但是这些格式被用在了程序中。

5．NNTP和其它的第三方协议
正因为JavaMail API在设计时考虑到与第三方协议实现提供商之间的分离，故我们可以很容易的添加一些第三方协议。SUN维护着一个第三方协议实现提供商的列表：http://java.sun.com/products/javamail/Third_Party.html，通过此列表我们可以找到所需要的而又不被SUN提供支持的第三方协议：比如NNTP这个新闻组协议和S/MIME这个安全的MIME协议。

三、安装
1．安装JavaMail
为了使用JavaMail API，需要从http://java.sun.com/products/javamail/downloads/index.html下载文件名格式为javamail-[version].zip的文件（这个文件中包括了JavaMail实现），并将其中的mail.jar文件添加到CLASSPATH中。这个实现提供了对SMTP、IMAP4、POP3的支持。
注意：在安装JavaMail实现之后，我们将在demo目录中发现许多有趣的简单实例程序。
在安装了JavaMail之后,我们还需要安装JavaBeans Activation Framework，因为这个框架是JavaMail API所需要的。如果我们使用J2EE的话，那么我们并无需单独下载JavaMail，因为它存在于J2EE.jar中，只需将J2EE.jar加入到CLASSPATH即可。

2．安装JavaBeans Activation Framework
从http://java.sun.com/products/javabeans/glasgow/jaf.html下载JavaBeans Activation Framework，并将其添加到CLASSPATH中。此框架增加了对任何数据块的分类、以及对它们的处理的特性。这些特性是JavaMail API需要的。虽然听起来这些特性非常模糊，但是它对于我们的JavaMail API来说只是提供了基本的MIME类型支持。
到此为止，我们应当把mail.jar和activation.jar都添加到了CLASSPATH中。
当然如果从方便的角度讲，直接把这两个Jar文件复制到JRE目录的lib/ext目录中也可以。

四、初次认识JavaMail API
1．了解我们的JavaMail环境
A．纵览JavaMail核心类结构
打开JavaMail.jar文件，我们将发现在javax.mail的包下面存在着一些核心类：Session、Message、Address、Authenticator、Transport、Store、Folder。而且在javax.mail.internet包中还有一些常用的子类。
B．Session
Session类定义了基本的邮件会话。就像Http会话那样，我们进行收发邮件的工作都是基于这个会话的。Session对象利用了java.util.Properties对象获得了邮件服务器、用户名、密码信息和整个应用程序都要使用到的共享信息。
Session类的构造方法是私有的，所以我们可以使用Session类提供的getDefaultInstance()这个静态工厂方法获得一个默认的Session对象：

Properties props = new Properties();
// fill props with any information
Session session = Session.getDefaultInstance(props, null);

或者使用getInstance()这个静态工厂方法获得自定义的Session:

Properties props = new Properties();
// fill props with any information
Session session = Session.getInstance(props, null);

从上面的两个例子中不难发现，getDefaultInstance()和getInstance()方法的第二个参数都是null，这是因为在上面的例子中并没有使用到邮件授权，下文中将对授权进行详细介绍。
从很多的实例看，在对mail server进行访问的过程中使用共享的Session是足够的，即使是工作在多个用户邮箱的模式下也不例外。

C．Message
当我们建立了Session对象后，便可以被发送的构造信息体了。在这里SUN提供了Message类型来帮助开发者完成这项工作。由于Message是一个抽象类，大多数情况下，我们使用javax.mail.internet.MimeMessage这个子类，该类是使用MIME类型、MIME信息头的邮箱信息。信息头只能使用US-ASCII字符，而非ASCII字符将通过编码转换为ASCII的方式使用。
为了建立一个MimeMessage对象，我们必须将Session对象作为MimeMessage构造方法的参数传入：

MimeMessage message = new MimeMessage(session);

注意：对于MimeMessage类来讲存在着多种构造方法，比如使用输入流作为参数的构造方法。

在建立了MimeMessage对象后，我们需要设置它的各个part，对于MimeMessage类来说，这些part就是MimePart接口。最基本的设置信息内容的方法就是通过表示信息内容和米么类型的参数调用setContent()方法：

message.setContent("Hello", "text/plain");

然而，如果我们所使用的MimeMessage中信息内容是文本的话，我们便可以直接使用setText()方法来方便的设置文本内容。

message.setText("Hello");

前面所讲的两种方法，对于文本信息，后者更为合适。而对于其它的一些信息类型，比如HTML信息，则要使用前者。
别忘记了，使用setSubject()方法对邮件设置邮件主题：

message.setSubject("First");

D．Address
到这里，我们已经建立了Session和Message，下面将介绍如何使用邮件地址类：Address。像Message一样，Address类也是一个抽象类，所以我们将使用javax.mail.internet.InternetAddress这个子类。
通过传入代表邮件地址的字符串，我们可以建立一个邮件地址类：

Address address = new InternetAddress("president@whitehouse.gov");

如果要在邮件地址后面增加名字的话，可以通过传递两个参数：代表邮件地址和名字的字符串来建立一个具有邮件地址和名字的邮件地址类：

Address address = new InternetAddress("president@whitehouse.gov", "George Bush");

本文在这里所讲的邮件地址类是为了设置邮件信息的发信人和收信人而准备的，在建立了邮件地址类后，我们通过message的setFrom()和setReplyTo()两种方法设置邮件的发信人：

message.setFrom(address);
message.setReplyTo(address);

若在邮件中存在多个发信人地址，我们可用addForm()方法增加发信人：

Address address[] = ...;
message.addFrom(address);

为了设置收信人，我们使用addRecipient()方法增加收信人，此方法需要使用Message.RecipientType的常量来区分收信人的类型：

message.addRecipient(type, address)

下面是Message.RecipientType的三个常量:
Message.RecipientType.TO
Message.RecipientType.CC
Message.RecipientType.BCC
因此，如果我们要发送邮件给总统，并发用一个副本给第一夫人的话，下面的方法将被用到：

Address toAddress = new InternetAddress("vice.president@whitehouse.gov");
Address ccAddress = new InternetAddress("first.lady@whitehouse.gov");
message.addRecipient(Message.RecipientType.TO, toAddress);
message.addRecipient(Message.RecipientType.CC, ccAddress);

JavaMail API并没有提供检查邮件地址有效性的机制。当然我们可以自己完成这个功能：验证邮件地址的字符是否按照RFC822规定的格式书写或者通过DNS服务器上的MX记录验证等。

E．Authenticator
像java.net类那样，JavaMail API通过使用授权者类（Authenticator）以用户名、密码的方式访问那些受到保护的资源，在这里“资源”就是指邮件服务器。在javax.mail包中可以找到这个JavaMail的授权者类（Authenticator）。
在使用Authenticator这个抽象类时，我们必须采用继承该抽象类的方式，并且该继承类必须具有返回PasswordAuthentication对象（用于存储认证时要用到的用户名、密码）getPasswordAuthentication()方法。并且要在Session中进行注册，使Session能够了解在认证时该使用哪个类。
下面代码片断中的MyAuthenticator就是一个Authenticator的子类。

Properties props = new Properties();
// fill props with any information
Authenticator auth = new MyAuthenticator();
Session session = Session.getDefaultInstance(props, auth);

F．Transport
在发送信息时，Transport类将被用到。这个类实现了发送信息的协议（通称为SMTP），此类是一个抽象类，我们可以使用这个类的静态方法send()来发送消息：

Transport.send(message);

当然，方法是多样的。我们也可由Session获得相应协议对应的Transport实例。并通过传递用户名、密码、邮件服务器主机名等参数建立与邮件服务器的连接，并使用sendMessage()方法将信息发送，最后关闭连接：

message.saveChanges(); // implicit with send()
Transport transport = session.getTransport("smtp");
transport.connect(host, username, password);
transport.sendMessage(message, message.getAllRecipients());
transport.close();

评论：上面的方法是一个很好的方法，尤其是在我们在同一个邮件服务器上发送多个邮件时。因为这时我们将在连接邮件服务器后连续发送邮件，然后再关闭掉连接。send()这个基本的方法是在每次调用时进行与邮件服务器的连接的，对于在同一个邮件服务器上发送多个邮件来讲可谓低效的方式。
注意：如果需要在发送邮件过程中监控mail命令的话，可以在发送前设置debug标志：

session.setDebug(true)。

G．Store和Folder
接收邮件和发送邮件很类似都要用到Session。但是在获得Session后，我们需要从Session中获取特定类型的Store，然后连接到Store，这里的Store代表了存储邮件的邮件服务器。在连接Store的过程中，极有可能需要用到用户名、密码或者Authenticator。

// Store store = session.getStore("imap");
Store store = session.getStore("pop3");
store.connect(host, username, password);

在连接到Store后，一个Folder对象即目录对象将通过Store的getFolder()方法被返回，我们可从这个Folder中读取邮件信息：

Folder folder = store.getFolder("INBOX");
folder.open(Folder.READ_ONLY);
Message message[] = folder.getMessages();

上面的例子首先从Store中获得INBOX这个Folder（对于POP3协议只有一个名为INBOX的Folder有效），然后以只读（Folder.READ_ONLY）的方式打开Folder，最后调用Folder的getMessages()方法得到目录中所有Message的数组。

注意：对于POP3协议只有一个名为INBOX的Folder有效，而对于IMAP协议，我们可以访问多个Folder（想想前面讲的IMAP协议）。而且SUN在设计Folder的getMessages()方法时采取了很智能的方式：首先接收新邮件列表，然后再需要的时候（比如读取邮件内容）才从邮件服务器读取邮件内容。
在读取邮件时，我们可以用Message类的getContent()方法接收邮件或是writeTo()方法将邮件保存，getContent()方法只接收邮件内容（不包含邮件头），而writeTo()方法将包括邮件头。

System.out.println(((MimeMessage)message).getContent());

在读取邮件内容后，别忘记了关闭Folder和Store。

folder.close(aBoolean);
store.close();

传递给Folder.close()方法的boolean 类型参数表示是否在删除操作邮件后更新Folder。

H．继续向前进！
在讲解了以上的七个Java Mail核心类定义和理解了简单的代码片断后，下文将详细讲解怎样使用这些类实现JavaMail API所要完成的高级功能。

五、使用JavaMail API
在明确了JavaMail API的核心部分如何工作后，本人将带领大家学习一些使用Java Mail API任务案例。
1．发送邮件
在获得了Session后，建立并填入邮件信息，然后发送它到邮件服务器。这便是使用Java Mail API发送邮件的过程，在发送邮件之前，我们需要设置SMTP服务器：通过设置Properties的mail.smtp.host属性。

String host = ...;
String from = ...;
String to = ...;

// Get system properties
Properties props = System.getProperties();

// Setup mail server
props.put("mail.smtp.host", host);

// Get session
Session session = Session.getDefaultInstance(props, null);

// Define message
MimeMessage message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO,
  new InternetAddress(to));
message.setSubject("Hello JavaMail");
message.setText("Welcome to JavaMail");
// Send message
Transport.send(message);

由于建立邮件信息和发送邮件的过程中可能会抛出异常，所以我们需要将上面的代码放入到try-catch结构块中。

2．接收邮件
为了在读取邮件，我们获得了session，并且连接到了邮箱的相应store，打开相应的Folder，然后得到我们想要的邮件，当然别忘记了在结束时关闭连接。

String host = ...;
String username = ...;
String password = ...;

// Create empty properties
Properties props = new Properties();

// Get session
Session session = Session.getDefaultInstance(props, null);

// Get the store
Store store = session.getStore("pop3");
store.connect(host, username, password);

// Get folder
Folder folder = store.getFolder("INBOX");
folder.open(Folder.READ_ONLY);

// Get directory
Message message[] = folder.getMessages();

for (int i=0, n=message.length; i   System.out.println(i + ": " + message[i].getFrom()[0]
     + "\t" + message[i].getSubject());
}

// Close connection
folder.close(false);
store.close();

上面的代码所作的是从邮箱中读取每个邮件，并且显示邮件的发信人地址和主题。从技术角度讲，这里存在着一个异常的可能：当发信人地址为空时，getFrom()[0]将抛出异常。

下面的代码片断有效的说明了如何读取邮件内容，在显示每个邮件发信人和主题后，将出现用户提示从而得到用户是否读取该邮件的确认，如果输入YES的话，我们可用Message.writeTo(java.io.OutputStream os)方法将邮件内容输出到控制台上，关于Message.writeTo()的具体用法请看JavaMail API。

BufferedReader reader = new BufferedReader (
  new InputStreamReader(System.in));

// Get directory
Message message[] = folder.getMessages();
for (int i=0, n=message.length; i  System.out.println(i + ": " + message[i].getFrom()[0]
    + "\t" + message[i].getSubject());

  System.out.println("Do you want to read message? " +
    "[YES to read/QUIT to end]");
  String line = reader.readLine();
  if ("YES".equals(line)) {
    message[i].writeTo(System.out);
  } else if ("QUIT".equals(line)) {
    break;
  }
}

3．删除邮件和标志
设置与message相关的Flags是删除邮件的常用方法。这些Flags表示了一些系统定义和用户定义的不同状态。在Flags类的内部类Flag中预定义了一些标志：
Flags.Flag.ANSWERED
Flags.Flag.DELETED
Flags.Flag.DRAFT
Flags.Flag.FLAGGED
Flags.Flag.RECENT
Flags.Flag.SEEN
Flags.Flag.USER
但需要在使用时注意的：标志存在并非意味着这个标志被所有的邮件服务器所支持。例如，对于删除邮件的操作，POP协议不支持上面的任何一个。所以要确定哪些标志是被支持的——通过访问一个已经打开的Folder对象的getPermanetFlags()方法，它将返回当前被支持的Flags类对象。
删除邮件时，我们可以设置邮件的DELETED标志：

message.setFlag(Flags.Flag.DELETED, true);

但是首先要采用READ_WRITE的方式打开Folder：

folder.open(Folder.READ_WRITE);

在对邮件进行删除操作后关闭Folder时，需要传递一个true作为对删除邮件的擦除确认。

folder.close(true);

Folder类中另一种用于删除邮件的方法expunge()也同样可删除邮件，但是它并不为sun提供的POP3实现支持，而其它第三方提供的POP3实现支持或者并不支持这种方法。
另外，介绍一种检查某个标志是否被设置的方法：Message.isSet(Flags.Flag flag)方法，其中参数为被检查的标志。

4．邮件认证
我们在前面已经学会了如何使用Authenticator类来代替直接使用用户名和密码这两字符串作为Session.getDefaultInstance()或者Session.getInstance()方法的参数。在前面的小试牛刀后，现在我们将了解到全面认识一下邮件认证。
我们在此取代了直接使用邮件服务器主机名、用户名、密码这三个字符串作为连接到POP3 Store的方式，使用存储了邮件服务器主机名信息的属性文件，并在获得Session时传入自定义的Authenticator实例：

// Setup properties
Properties props = System.getProperties();
props.put("mail.pop3.host", host);

// Setup authentication, get session
Authenticator auth = new PopupAuthenticator();
Session session = Session.getDefaultInstance(props, auth);

// Get the store
Store store = session.getStore("pop3");
store.connect();

PopupAuthenticator类继承了抽象类Authenticator，并且通过重载Authenticator类的getPasswordAuthentication()方法返回PasswordAuthentication类对象。而getPasswordAuthentication()方法的参数param是以逗号分割的用户名、密码组成的字符串。

import javax.mail.*;
import java.util.*;

public class PopupAuthenticator extends Authenticator {

  public PasswordAuthentication getPasswordAuthentication(String param) {
    String username, password;

    StringTokenizer st = new StringTokenizer(param, ",");
    username = st.nextToken();
    password = st.nextToken();

    return new PasswordAuthentication(username, password);
  }

}

5．回复邮件
回复邮件的方法很简单：使用Message类的reply()方法，通过配置回复邮件的收件人地址和主题（如果没有提供主题的话，系统将默认将“Re：”作为邮件的主体），这里不需要设置任何的邮件内容，只要复制发信人或者reply-to到新的收件人。而reply()方法中的boolean参数表示是否将邮件回复给发送者（参数值为false），或是恢复给所有人（参数值为true）。
补充一下，reply-to地址需要在发信时使用setReplyTo()方法设置。

MimeMessage reply = (MimeMessage)message.reply(false);
reply.setFrom(new InternetAddress("president@whitehouse.gov"));
reply.setText("Thanks");
Transport.send(reply);

6．转发邮件
转发邮件的过程不如前面的回复邮件那样简单，它将建立一个转发邮件，这并非一个方法就能做到。
每个邮件是由多个部分组成，每个部分称为一个邮件体部分，是一个BodyPart类对象，对于MIME类型邮件来讲就是MimeBodyPart类对象。这些邮件体包含在成为Multipart的容器中对于MIME类型邮件来讲就是MimeMultiPart类对象。在转发邮件时，我们建立一个文字邮件体部分和一个被转发的文字邮件体部分，然后将这两个邮件体放到一个Multipart中。说明一下，复制一个邮件内容到另一个邮件的方法是仅复制它的DataHandler（数据处理者）即可。这是由JavaBeans Activation Framework定义的一个类，它提供了对邮件内容的操作命令的访问、管理了邮件内容操作，是不同的数据源和数据格式之间的一致性接口。

// Create the message to forward
Message forward = new MimeMessage(session);

// Fill in header
forward.setSubject("Fwd: " + message.getSubject());
forward.setFrom(new InternetAddress(from));
forward.addRecipient(Message.RecipientType.TO,
  new InternetAddress(to));

// Create your new message part
BodyPart messageBodyPart = new MimeBodyPart();
messageBodyPart.setText(
  "Here you go with the original message:\n\n");

// Create a multi-part to combine the parts
Multipart multipart = new MimeMultipart();
multipart.addBodyPart(messageBodyPart);

// Create and fill part for the forwarded content
messageBodyPart = new MimeBodyPart();
messageBodyPart.setDataHandler(message.getDataHandler());

// Add part to multi part
multipart.addBodyPart(messageBodyPart);

// Associate multi-part with message
forward.setContent(multipart);

// Send message
Transport.send(forward);

7．使用附件
附件作为与邮件相关的资源经常以文本、表格、图片等格式出现，如流行的邮件客户端一样，我们可以用JavaMail API从邮件中获取附件或是发送带有附件的邮件。

A．发送带有附件的邮件
发送带有附件的邮件的过程有些类似转发邮件，我们需要建立一个完整邮件的各个邮件体部分，在第一个部分（即我们的邮件内容文字）后，增加一个具有DataHandler的附件而不是在转发邮件时那样复制第一个部分的DataHandler。

如果我们将文件作为附件发送，那么要建立FileDataSource类型的对象作为附件数据源；如果从URL读取数据作为附件发送，那么将要建立URLDataSource类型的对象作为附件数据源。

然后将这个数据源（FileDataSource或是URLDataSource）对象作为DataHandler类构造方法的参数传入，从而建立一个DataHandler对象作为数据源的DataHandler。

接着将这个DataHandler设置为邮件体部分的DataHandler。这样就完成了邮件体与附件之间的关联工作，下面的工作就是BodyPart的setFileName()方法设置附件名为原文件名。

最后将两个邮件体放入到Multipart中，设置邮件内容为这个容器Multipart，发送邮件。

// Define message
Message message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO,
  new InternetAddress(to));
message.setSubject("Hello JavaMail Attachment");

// Create the message part
BodyPart messageBodyPart = new MimeBodyPart();

// Fill the message
messageBodyPart.setText("Pardon Ideas");

Multipart multipart = new MimeMultipart();
multipart.addBodyPart(messageBodyPart);

// Part two is attachment
messageBodyPart = new MimeBodyPart();
DataSource source = new FileDataSource(filename);
messageBodyPart.setDataHandler(new DataHandler(source));
messageBodyPart.setFileName(filename);
multipart.addBodyPart(messageBodyPart);

// Put parts in message
message.setContent(multipart);

// Send the message
Transport.send(message);

如果我们使用servlet实现发送带有附件的邮件，则必须上传附件给servlet，这时需要注意提交页面form中对编码类型的设置应为multipart/form-data。

    method=post action="/myservlet">



B．读取邮件中的附件
读取邮件中的附件的过程要比发送它的过程复杂一点。因为带有附件的邮件是多部分组成的，我们必须处理每一个部分获得邮件的内容和附件。
但是如何辨别邮件信息内容和附件呢？Sun在Part类（BodyPart类实现的接口类）中提供了getDisposition()方法让开发者获得邮件体部分的部署类型，当该部分是附件时，其返回之将是Part.ATTACHMENT。但附件也可以没有部署类型的方式存在或者部署类型为Part.INLINE，无论部署类型为Part.ATTACHMENT还是Part.INLINE，我们都能把该邮件体部分导出保存。

Multipart mp = (Multipart)message.getContent();

for (int i=0, n=multipart.getCount(); i  Part part = multipart.getBodyPart(i));

  String disposition = part.getDisposition();

  if ((disposition != null) &&
      ((disposition.equals(Part.ATTACHMENT) ||
       (disposition.equals(Part.INLINE))) {
    saveFile(part.getFileName(), part.getInputStream());
  }
}

下列代码中使用了saveFile方法是自定义的方法，它根据附件的文件名建立一个文件，如果本地磁盘上存在名为附件的文件，那么将在文件名后增加数字表示区别。然后从邮件体中读取数据写入到本地文件中（代码省略）。

// from saveFile()
File file = new File(filename);
for (int i=0; file.exists(); i++) {
  file = new File(filename+i);
}

以上是邮件体部分被正确设置的简单例子，如果邮件体部分的部署类型为null，那么我们通过获得邮件体部分的MIME类型来判断其类型作相应的处理，代码结构框架如下：

if (disposition == null) {
  // Check if plain
  MimeBodyPart mbp = (MimeBodyPart)part;
  if (mbp.isMimeType("text/plain")) {
    // Handle plain
  } else {
    // Special non-attachment cases here of
    // image/gif, text/html, ...
  }
...
}

8．处理HTML邮件
前面的例子中发送的邮件都是以文本为内容的（除了附件），下面将介绍如何接收和发送基于HTML的邮件。
A．发送HTML邮件
假如我们需要发送一个HTML文件作为邮件内容，并使邮件客户端在读取邮件时获取相关的图片或者文字的话，只要设置邮件内容为html代码，并设置内容类型为text/html即可：

String htmlText = "
Hello
" +
  "";
message.setContent(htmlText, "text/html"));

请注意：这里的图片并不是在邮件中内嵌的，而是在URL中定义的。邮件接收者只有在线时才能看到。
在接收邮件时，如果我们使用JavaMail API接收邮件的话是无法实现以HTML方式显示邮件内容的。因为JavaMail API邮件内容视为二进制流。所以要显示HTML内容的邮件，我们必须使用JEditorPane或者第三方HTML展现组件。

以下代码显示了如何使用JEditorPane显示邮件内容：

if (message.getContentType().equals("text/html")) {
  String content = (String)message.getContent();
  JFrame frame = new JFrame();
  JEditorPane text = new JEditorPane("text/html", content);
  text.setEditable(false);
  JScrollPane pane = new JScrollPane(text);
  frame.getContentPane().add(pane);
  frame.setSize(300, 300);
  frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  frame.show();
}

B．在邮件中包含图片
如果我们在邮件中使用HTML作为内容，那么最好将HTML中使用的图片作为邮件的一部分，这样无论是否在线都会正确的显示HTML中的图片。处理方法就是将HTML中用到的图片作为邮件附件并使用特殊的cid URL作为图片的引用，这个cid就是对图片附件的Content-ID头的引用。
处理内嵌图片就像向邮件中添加附件一样，不同之处在于我们必须通过设置图片附件所在的邮件体部分的header中Content-ID为一个随机字符串，并在HTML中img的src标记中设置为该字符串。这样就完成了图片附件与HTML的关联。

String file = ...;

// Create the message
Message message = new MimeMessage(session);

// Fill its headers
message.setSubject("Embedded Image");
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO,
  new InternetAddress(to));

// Create your new message part
BodyPart messageBodyPart = new MimeBodyPart();
String htmlText = "
Hello
" +
  "";
messageBodyPart.setContent(htmlText, "text/html");

// Create a related multi-part to combine the parts
MimeMultipart multipart = new MimeMultipart("related");
multipart.addBodyPart(messageBodyPart);

// Create part for the image
messageBodyPart = new MimeBodyPart();

// Fetch the image and associate to part
DataSource fds = new FileDataSource(file);
messageBodyPart.setDataHandler(new DataHandler(fds));
messageBodyPart.setHeader("Content-ID","");

// Add part to multi-part
multipart.addBodyPart(messageBodyPart);

// Associate multi-part with message
message.setContent(multipart);

9．在邮件中搜索短语
JavaMail API提供了过滤器机制，它被用来建立搜索短语。这个短语由javax.mail.search包中的SearchTerm抽象类来定义，在定义后我们便可以使用Folder的Search()方法在Folder中查找邮件：

SearchTerm st = ...;
Message[] msgs = folder.search(st);

下面有22个不同的类（继承了SearchTerm类）供我们使用：
AND terms (class AndTerm)
OR terms (class OrTerm)
NOT terms (class NotTerm)
SENT DATE terms (class SentDateTerm)
CONTENT terms (class BodyTerm)
HEADER terms (FromTerm / FromStringTerm, RecipientTerm / RecipientStringTerm, SubjectTerm, etc.)
使用这些类定义的断语集合，我们可以构造一个逻辑表达式，并在Folder中进行搜索。下面是一个实例：在Folder中搜索邮件主题含有“ADV”字符串或者发信人地址为friend@public.com的邮件。

SearchTerm st =
  new OrTerm(
    new SubjectTerm("ADV:"),
    new FromStringTerm("friend@public.com"));
Message[] msgs = folder.search(st);

六、参考资源
JavaMail API Home
Sun’s JavaMail API基础
 JavaBeans Activation Framework Home
javamail-interest mailing list
Sun's JavaMail FAQ
jGuru's JavaMail FAQ
Third Party Products List

七、代码下载
http://java.sun.com/developer/onlineTraining/JavaMail/exercises.html

重归本垒（Bing） 2006-07-20 09:24 发表评论