IT博客-快乐着飞舞着-随笔分类-Java

Spring + hibernate 的错误

快乐着飞舞着 — Tue, 08 Aug 2006 11:00:00 GMT

摘要: 18 : 55 : 43 , 750 ERROR [ContextLoaderPlugIn] Context initialization failedorg.springframework.beans.factory.BeanCreationException: Error creating bean with name ... 阅读全文

快乐着飞舞着 2006-08-08 19:00 发表评论

一个诡异问题终于得已解决

快乐着飞舞着 — Tue, 08 Aug 2006 09:49:00 GMT

摘要: 最近在学着在 struts 中使用 spring ,但是在发布到服务器上时总是有如表一的错误。所有的配置文件都是正确的，在网上就根本就没有什么解决办法。下载一个例子能发布成功，配置文件基本一致，我仔细比较了两个文件发现差别就是发布到服务器上的war文件是否在/WEB-INF/lib文件夹下包含了struts 的所有类库，我当时觉得问题就是出在这里。把所有的依赖类库复制到jboss ser... 阅读全文

快乐着飞舞着 2006-08-08 17:49 发表评论

Hibernate 的主键生成

快乐着飞舞着 — Sat, 05 Aug 2006 13:51:00 GMT

Hibernate 的主键生成中的 uuid.hex本来为什么不输出long 类型的而要输出一个string 类型的呢？总觉得一个varchar2 作为主键怪怪的。。。

快乐着飞舞着 2006-08-05 21:51 发表评论

Hibernate 的错误

快乐着飞舞着 — Sun, 23 Jul 2006 15:21:00 GMT

2006-07-23 23:14:53,796 [main] WARN org.hibernate.impl.SessionFactoryObjectFactory - Could not bind factory to JNDI
javax.naming.NoInitialContextException: Need to specify class name in environment or system property, or as an applet parameter, or in an application resource file: java.naming.factory.initial
at javax.naming.spi.NamingManager.getInitialContext(NamingManager.java:645)
at javax.naming.InitialContext.getDefaultInitCtx(InitialContext.java:247)
at javax.naming.InitialContext.getURLOrDefaultInitCtx(InitialContext.java:284)
at javax.naming.InitialContext.getNameParser(InitialContext.java:439)
at org.hibernate.util.NamingHelper.bind(NamingHelper.java:52)
at org.hibernate.impl.SessionFactoryObjectFactory.addInstance(SessionFactoryObjectFactory.java:90)
at org.hibernate.impl.SessionFactoryImpl.(SessionFactoryImpl.java:291)
at org.hibernate.cfg.Configuration.buildSessionFactory(Configuration.java:1176)
at reene.study.hibernate.test.TestMain.main(TestMain.java:19)

疑惑中

待解决....
在网上找到如下内容：
（3）报错：Could not bind factory to JNDI
此错误是配置文件的问题，如果hibernate配置文件有session_factory_name这个变量，会试图将一个SessionFactory实例以foo为名bind到jndi上，而有的application container不支持jndi绑定。把这个变量去掉即可。

解决问题

把引用代码也要修改：
大致改成这样：

1 SessionFactory sf = new Configuration().configure()
2                     .buildSessionFactory();
3             Session session = sf.openSession();
4             Transaction tx = session.beginTransaction();

快乐着飞舞着 2006-07-23 23:21 发表评论

"struts中文问题"，"struts国际化问题"??终极解决方案[转载]

快乐着飞舞着 — Tue, 13 Jun 2006 13:32:00 GMT

引用自：
http://hellocoffeecat.spaces.msn.com/Blog/cns!F0C1403231EB3BB0!151.entry
http://hellocoffeecat.spaces.msn.com/blog/cns!F0C1403231EB3BB0!151.trak

"struts中文问题"，"struts国际化问题"??终极解决方案

Java本身就支持多国语言编码，不需要写任何程序，可以很简单的
实现。
秘诀就是两点：

1、所有HTML/JSP页面全部采用UTF-8编码

2、客户端浏览器完全支持UTF-8编码

步骤：
1、首先把所有的HTML/JSP的ContentType都设为UTF-8

2、然后对于JSP程序中的非ASCII码提示信息都不应该写在程序里面，都应该放在
application.properties里面统一管理。

3、对HTML用native2ascii工具统一做一次处理，把HTML中的非ASCII码都转换为Unicode编码。

4、针对不同的语言，写不同的application.properties，比如说简体中文是
application_zh_CN.properties，繁体中文是application_zh_TW.properties这样，然后对这些配置信
息文件同样用native2ascii工具处理一次，把非ASCII码统统转为Unicode编码。

5、在Servlet的request.getCharacterEncoding()获得客户端的操作系统默认编码，然后set到Struts
的HTTPSession的Locale中。

OK！现在不同的客户访问，就会显示不同的语言版本了。你可以看看此时你的浏览器的字符集，就是
UTF-8。现在你的网站和Google一样了，嘿嘿，其实你有心的话，看看你的浏览器访问Google的时候是
什么字符集吧

切记：所有的HTML/JSP都要设为UTF-8编码，所有的文件中的非ASCII码字符都要用native2ascii工具转
为用ASCII表示的Unicode编码。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
原创
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
上面所述是我从网上下的一篇于中文问题的解决方案，确切的说应该是关于Struts的国际化问题，下面我结合我的实践谈谈具体如何实现Struts的国际化问题，我对理论不是非常精通，我只能完全凭自己的理解和实践来讲述，所以下面讲的内容可能不是非常正确，还请大家原谅。但有一点可以肯定，我通过自己的努力解决了Struts的中文问题，并实现Struts的国际化，其实一切并不复杂，下面是具体步骤：

0.遇到的问题(这些问题也许不会同时出现)
a.中文数据从数据库中到jsp中后就变成了"????"
b.做好的中文properties文件，其中的中文value在页面显示乱码
c.jsp文件中的中文到浏览器后显示时也是乱码（建议不要在jsp文件中输入中文，尽量放在properties文件中）
d.由jsp传给bean的中文值，再由bean传回页面又是乱码
e.当更换本地浏览器的语言选项时，Web应用程序不能自动根据你的locale选择合适的*.properties文件。导致Web应用程序不能国际化。
1.环境：
Web服务器： Tomcat 5.0.19
操作系统： Win2000 Server
JVM ： jdk 1.4
数据库： Oracle 8.1.7
开发工具： struts studio 5.2 pro for eclipse
2.先将所有*.jsp 网页中开头处加入

<%@ page language="java" contentType="text/html; charset=utf-8" %>
再设置

3.然后编辑好两个*.properties文件，放在classes文件夹下你指定的地方，这里是放在/web-inf/classes/com/wiley 下，它们分别是：

ApplicationResources.properties (英文资源文件)
ApplicationResources_zh.properties (中文资源文件)
随便用什么工具编写都行啊！
4.将ApplicationResources_zh.properties转码成gb2312。上面引文说要转成UTF-8，结果我试了，不行。转成gb2312就行了，操作是。
将ApplicationResources_zh.properties更名为ApplicationResources_xx.properties
在DOS命令行进入ApplicationResources_xx.properties所在的文件夹
使用命令：native2ascii -encoding gb2312 ApplicationResources_xx.properties ApplicationResources_zh.properties(至于你为什么会出现“native2ascii不是内部命令”，，请查其它资料，可能你要设置环境变量，因为他是jdk的文件夹bin下的一个应用程序)
5.接下来配置struts-config.xml,很简单，我们加入：

就行了；

到此已能解决大多数中文问题。如上面所说的a,b,e 现在打开浏览器，选择菜单：工具》internet选项》语言，将“中文－中国[zh-cn]”删掉，添加一个“英语－英国[zh-gb]”确定后，重启Tomcat,输入网址你就会发现，你的页面的文本信息就会用的是ApplicationResources.properties (英文资源文件)中的内容。如果换回“中文－中国[zh-cn]”，它就会显示ApplicationResources_zh.properties (中文资源文件)中的中文内容。

至于问题“c.jsp文件中的中文到浏览器后显示时也是乱码” 你就要用与第4步类似的方法来重新对*.jsp 文件编码，这时-encoding的参数就要用UTF-8了，如果你用的也是struts studio 5.2 pro for eclipse工具，这一步就免了。它会自动用UTF-8的格式存储。
至于问题“d.由jsp传给bean的中文值，再由bean传回页面又是乱码”的解决，我只是加了个过滤器。
你可以现在web.xml中加入：

Set Character Encoding

com.wiley.SetCharacterEncodingFilter

encoding

utf-8

ignore

true

Set Character Encoding

action

然后在你指定的包内加个java文件我放在了/web-inf/classes/com/wiley 里，下面是源代码：

/*
* XP Forum
*
* Copyright (c) 2002-2003 RedSoft Group. All rights reserved.
*
*/
package com.huahang.tj.struts.filters;

import javax.servlet.*;
import java.io.IOException;

/**
*

Filter that sets the character encoding to be used in parsing the
* incoming request, either unconditionally or only if the client did not
* specify a character encoding. Configuration of this filter is based on
* the following initialization parameters:

encoding - The character encoding to be configured
* for this request, either conditionally or unconditionally based on
* the ignore initialization parameter. This parameter
* is required, so there is no default.

ignore - If set to "true", any character encoding
* specified by the client is ignored, and the value returned by the
* selectEncoding() method is set. If set to "false,
* selectEncoding() is called only if the
* client has not already specified an encoding. By default, this
* parameter is set to "true".

*
*

Although this filter can be used unchanged, it is also easy to
* subclass it and make the selectEncoding() method more
* intelligent about what encoding to choose, based on characteristics of
* the incoming request (such as the values of the Accept-Language
* and User-Agent headers, or a value stashed in the current
* user´s session.

*
* @author John Wong
*
* @version $Id: SetCharacterEncodingFilter.java,v 1.1 2002/04/10 13:59:27 johnwong Exp $
*/
public class SetCharacterEncodingFilter implements Filter {

// ----------------------------------------------------- Instance Variables

/**
* The default character encoding to set for requests that pass through
* this filter.
*/
protected String encoding = null;

/**
* The filter configuration object we are associated with. If this value
* is null, this filter instance is not currently configured.
*/
protected FilterConfig filterConfig = null;

/**
* Should a character encoding specified by the client be ignored?
*/
protected boolean ignore = true;

// --------------------------------------------------------- Public Methods

/**
* Take this filter out of service.
*/
public void destroy() {

this.encoding = null;
this.filterConfig = null;

}

/**
* Select and set (if specified) the character encoding to be used to
* interpret request parameters for this request.
*
* @param request The servlet request we are processing
* @param result The servlet response we are creating
* @param chain The filter chain we are processing
*
* @exception IOException if an input/output error occurs
* @exception ServletException if a servlet error occurs
*/
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain)
throws IOException, ServletException {

// Conditionally select and set the character encoding to be used
if (ignore || (request.getCharacterEncoding() == null)) {
String encoding = selectEncoding(request);
if (encoding != null)
request.setCharacterEncoding(encoding);
}

// Pass control on to the next filter
chain.doFilter(request, response);

}

/**
* Place this filter into service.
*
* @param filterConfig The filter configuration object
*/
public void init(FilterConfig filterConfig) throws ServletException {

this.filterConfig = filterConfig;
this.encoding = filterConfig.getInitParameter("encoding");
String value = filterConfig.getInitParameter("ignore");
if (value == null)
this.ignore = true;
else if (value.equalsIgnoreCase("true"))
this.ignore = true;
else if (value.equalsIgnoreCase("yes"))
this.ignore = true;
else
this.ignore = false;

}

// ------------------------------------------------------ Protected Methods

/**
* Select an appropriate character encoding to be used, based on the
* characteristics of the current request and/or filter initialization
* parameters. If no character encoding should be set, return
* null.
*

* The default implementation unconditionally returns the value configured
* by the encoding initialization parameter for this
* filter.
*
* @param request The servlet request we are processing
*/
protected String selectEncoding(ServletRequest request) {

return (this.encoding);

}

}//EOC

到此我遇到的中文问题已全部得到解决，并从中理解到struts的国际化的深刻含义。
我个人觉得struts作为一个功能强大的应用框架，应该早就考虑到它的国际化问题，并在实际应用中不会很复杂，只要我们遵循一些规则，就可以尽情享受struts给我们带来的无穷乐趣。希望以上所述对大家有所帮助。

快乐着飞舞着 2006-06-13 21:32 发表评论

应用HttpClient来对付各种顽固的WEB服务器(3) [转]

快乐着飞舞着 — Sun, 09 Oct 2005 05:07:00 GMT

4．模拟输入用户名和口令进行登录

本小节应该说是HTTP客户端编程中最常碰见的问题，很多网站的内容都只是对注册用户可见的，这种情况下就必须要求使用正确的用户名和口令登录成功后，方可浏览到想要的页面。因为HTTP协议是无状态的，也就是连接的有效期只限于当前请求，请求内容结束后连接就关闭了。在这种情况下为了保存用户的登录信息必须使用到Cookie机制。以JSP/Servlet为例，当浏览器请求一个JSP或者是Servlet的页面时，应用服务器会返回一个参数，名为jsessionid（因不同应用服务器而异），值是一个较长的唯一字符串的Cookie，这个字符串值也就是当前访问该站点的会话标识。浏览器在每访问该站点的其他页面时候都要带上jsessionid这样的Cookie信息，应用服务器根据读取这个会话标识来获取对应的会话信息。

对于需要用户登录的网站，一般在用户登录成功后会将用户资料保存在服务器的会话中，这样当访问到其他的页面时候，应用服务器根据浏览器送上的Cookie中读取当前请求对应的会话标识以获得对应的会话信息，然后就可以判断用户资料是否存在于会话信息中，如果存在则允许访问页面，否则跳转到登录页面中要求用户输入帐号和口令进行登录。这就是一般使用JSP开发网站在处理用户登录的比较通用的方法。

这样一来，对于HTTP的客户端来讲，如果要访问一个受保护的页面时就必须模拟浏览器所做的工作，首先就是请求登录页面，然后读取Cookie值；再次请求登录页面并加入登录页所需的每个参数；最后就是请求最终所需的页面。当然在除第一次请求外其他的请求都需要附带上Cookie信息以便服务器能判断当前请求是否已经通过验证。说了这么多，可是如果你使用httpclient的话，你甚至连一行代码都无需增加，你只需要先传递登录信息执行登录过程，然后直接访问想要的页面，跟访问一个普通的页面没有任何区别，因为类HttpClient已经帮你做了所有该做的事情了，太棒了！下面的例子实现了这样一个访问的过程。

* Created on 2003-12-7 by Liudong

package http.demo;

import org.apache.commons.httpclient.*;

import org.apache.commons.httpclient.cookie.*;

import org.apache.commons.httpclient.methods.*;

/**

* 用来演示登录表单的示例

* @author Liudong

public class FormLoginDemo {

static final String LOGON_SITE = "localhost";

static final int LOGON_PORT = 8080;

public static void main(String[] args) throws Exception{

HttpClient client = new HttpClient();

client.getHostConfiguration().setHost(LOGON_SITE, LOGON_PORT);

//模拟登录页面login.jsp->main.jsp

PostMethod post = new PostMethod("/main.jsp");

NameValuePair name = new NameValuePair("name", "ld");

NameValuePair pass = new NameValuePair("password", "ld");

post.setRequestBody(new NameValuePair[]{name,pass});

int status = client.executeMethod(post);

System.out.println(post.getResponseBodyAsString());

post.releaseConnection();

//查看cookie信息

CookieSpec cookiespec = CookiePolicy.getDefaultSpec();

Cookie[] cookies = cookiespec.match(LOGON_SITE, LOGON_PORT, "/", false, client.getState().getCookies());

if (cookies.length == 0) {

System.out.println("None");

} else {

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

System.out.println(cookies[i].toString());

}

//访问所需的页面main2.jsp

GetMethod get = new GetMethod("/main2.jsp");

client.executeMethod(get);

System.out.println(get.getResponseBodyAsString());

get.releaseConnection();

}

5．提交XML格式参数

提交XML格式的参数很简单，仅仅是一个提交时候的ContentType问题，下面的例子演示从文件文件中读取XML信息并提交给服务器的过程，该过程可以用来测试Web服务。

import java.io.File;

import java.io.FileInputStream;

import org.apache.commons.httpclient.HttpClient;

import org.apache.commons.httpclient.methods.EntityEnclosingMethod;

import org.apache.commons.httpclient.methods.PostMethod;

/**

* 用来演示提交XML格式数据的例子

public class PostXMLClient {

public static void main(String[] args) throws Exception {

File input = new File(“test.xml”);

PostMethod post = new PostMethod(“http://localhost:8080/httpclient/xml.jsp”);

// 设置请求的内容直接从文件中读取

post.setRequestBody(new FileInputStream(input));

if (input.length() < Integer.MAX_VALUE)

post.setRequestContentLength(input.length());

else post.setRequestContentLength(EntityEnclosingMethod.CONTENT_LENGTH_CHUNKED);

// 指定请求内容的类型

post.setRequestHeader("Content-type", "text/xml; charset=GBK");

HttpClient httpclient = new HttpClient();

int result = httpclient.executeMethod(post);

System.out.println("Response status code: " + result);

System.out.println("Response body: ");

System.out.println(post.getResponseBodyAsString());

post.releaseConnection();

}

(浏览全文引用此文)
文章来源:http://www.blogcn.com/user28/reene/blog/22216733.html

快乐着飞舞着 2005-10-09 13:07 发表评论

应用HttpClient来对付各种顽固的WEB服务器(2) [转]

快乐着飞舞着 — Sun, 09 Oct 2005 05:07:00 GMT

2．以GET或者POST方式向网页提交参数

其实前面一个最简单的示例中我们已经介绍了如何使用GET或者POST方式来请求一个页面，本小节与之不同的是多了提交时设定页面所需的参数，我们知道如果是GET的请求方式，那么所有参数都直接放到页面的URL后面用问号与页面地址隔开，每个参数用&隔开，例如：http://java.sun.com?name=liudong&mobile=123456，但是当使用POST方法时就会稍微有一点点麻烦。本小节的例子演示向如何查询手机号码所在的城市，代码如下：

* Created on 2003-12-7 by Liudong

package http.demo;

import java.io.IOException;

import org.apache.commons.httpclient.*;

import org.apache.commons.httpclient.methods.*;

/**

* 提交参数演示

* 该程序连接到一个用于查询手机号码所属地的页面

* 以便查询号码段1330227所在的省份以及城市

* @author Liudong

public class SimpleHttpClient {

public static void main(String[] args) throws IOException

{

HttpClient client = new HttpClient();

client.getHostConfiguration().setHost("www.imobile.com.cn", 80, "http");

HttpMethod method = getPostMethod();//使用POST方式提交数据

client.executeMethod(method);

//打印服务器返回的状态

System.out.println(method.getStatusLine());

//打印结果页面

String response =

new String(method.getResponseBodyAsString().getBytes("8859_1"));

//打印返回的信息

System.out.println(response);

method.releaseConnection();

}

/**

* 使用GET方式提交数据

* @return

private static HttpMethod getGetMethod(){

return new GetMethod("/simcard.php?simcard=1330227");

}

/**

* 使用POST方式提交数据

* @return

private static HttpMethod getPostMethod(){

PostMethod post = new PostMethod("/simcard.php");

NameValuePair simcard = new NameValuePair("simcard","1330227");

post.setRequestBody(new NameValuePair[] { simcard});

return post;

}

在上面的例子中页面http://www.imobile.com.cn/simcard.php需要一个参数是simcard，这个参数值为手机号码段，即手机号码的前七位，服务器会返回提交的手机号码对应的省份、城市以及其他详细信息。GET的提交方法只需要在URL后加入参数信息，而POST则需要通过NameValuePair类来设置参数名称和它所对应的值

3．处理页面重定向

在JSP/Servlet编程中response.sendRedirect方法就是使用HTTP协议中的重定向机制。它与JSP中的的区别在于后者是在服务器中实现页面的跳转，也就是说应用容器加载了所要跳转的页面的内容并返回给客户端；而前者是返回一个状态码，这些状态码的可能值见下表，然后客户端读取需要跳转到的页面的URL并重新加载新的页面。就是这样一个过程，所以我们编程的时候就要通过HttpMethod.getStatusCode()方法判断返回值是否为下表中的某个值来判断是否需要跳转。如果已经确认需要进行页面跳转了，那么可以通过读取HTTP头中的location属性来获取新的地址。

状态码
对应HttpServletResponse的常量
详细描述

301
SC_MOVED_PERMANENTLY
页面已经永久移到另外一个新地址

302
SC_MOVED_TEMPORARILY
页面暂时移动到另外一个新的地址

303
SC_SEE_OTHER
客户端请求的地址必须通过另外的URL来访问

307
SC_TEMPORARY_REDIRECT
同SC_MOVED_TEMPORARILY

下面的代码片段演示如何处理页面的重定向

client.executeMethod(post);

System.out.println(post.getStatusLine().toString());

post.releaseConnection();

//检查是否重定向

int statuscode = post.getStatusCode();

if ((statuscode == HttpStatus.SC_MOVED_TEMPORARILY) ||

(statuscode == HttpStatus.SC_MOVED_PERMANENTLY) ||

(statuscode == HttpStatus.SC_SEE_OTHER) ||

(statuscode == HttpStatus.SC_TEMPORARY_REDIRECT)) {

//读取新的URL地址

Header header = post.getResponseHeader("location");

if (header != null) {

String newuri = header.getValue();

if ((newuri == null) || (newuri.equals("")))

newuri = "/";

GetMethod redirect = new GetMethod(newuri);

client.executeMethod(redirect);

System.out.println("Redirect:"+ redirect.getStatusLine().toString());

redirect.releaseConnection();

} else

System.out.println("Invalid redirect");

}

我们可以自行编写两个JSP页面，其中一个页面用response.sendRedirect方法重定向到另外一个页面用来测试上面的例子。

(浏览全文引用此文)
文章来源:http://www.blogcn.com/user28/reene/blog/22216676.html

快乐着飞舞着 2005-10-09 13:07 发表评论

应用HttpClient来对付各种顽固的WEB服务器(1) [转]

快乐着飞舞着 — Sun, 09 Oct 2005 05:07:00 GMT

一般的情况下我们都是使用IE或者Navigator浏览器来访问一个WEB服务器，用来浏览页面查看信息或者提交一些数据等等。所访问的这些页面有的仅仅是一些普通的页面，有的需要用户登录后方可使用，或者需要认证以及是一些通过加密方式传输，例如HTTPS。目前我们使用的浏览器处理这些情况都不会构成问题。不过你可能在某些时候需要通过程序来访问这样的一些页面，比如从别人的网页中“偷”一些数据；利用某些站点提供的页面来完成某种功能，例如说我们想知道某个手机号码的归属地而我们自己又没有这样的数据，因此只好借助其他公司已有的网站来完成这个功能，这个时候我们需要向网页提交手机号码并从返回的页面中解析出我们想要的数据来。如果对方仅仅是一个很简单的页面，那我们的程序会很简单，本文也就没有必要大张旗鼓的在这里浪费口舌。但是考虑到一些服务授权的问题，很多公司提供的页面往往并不是可以通过一个简单的URL就可以访问的，而必须经过注册然后登录后方可使用提供服务的页面，这个时候就涉及到COOKIE问题的处理。我们知道目前流行的动态网页技术例如ASP、JSP无不是通过COOKIE来处理会话信息的。为了使我们的程序能使用别人所提供的服务页面，就要求程序首先登录后再访问服务页面，这过程就需要自行处理cookie，想想当你用java.net.HttpURLConnection来完成这些功能时是多么恐怖的事情啊！况且这仅仅是我们所说的顽固的WEB服务器中的一个很常见的“顽固”！再有如通过HTTP来上传文件呢？不需要头疼，这些问题有了“它”就很容易解决了！

我们不可能列举所有可能的顽固，我们会针对几种最常见的问题进行处理。当然了，正如前面说到的，如果我们自己使用java.net.HttpURLConnection来搞定这些问题是很恐怖的事情，因此在开始之前我们先要介绍一下一个开放源码的项目，这个项目就是Apache开源组织中的httpclient，它隶属于Jakarta的commons项目，目前的版本是2.0RC2。commons下本来已经有一个net的子项目，但是又把httpclient单独提出来，可见http服务器的访问绝非易事。

Commons-httpclient项目就是专门设计来简化HTTP客户端与服务器进行各种通讯编程。通过它可以让原来很头疼的事情现在轻松的解决，例如你不再管是HTTP或者HTTPS的通讯方式，告诉它你想使用HTTPS方式，剩下的事情交给httpclient替你完成。本文会针对我们在编写HTTP客户端程序时经常碰到的几个问题进行分别介绍如何使用httpclient来解决它们，为了让读者更快的熟悉这个项目我们最开始先给出一个简单的例子来读取一个网页的内容，然后循序渐进解决掉前进中的所有问题。

1．读取网页(HTTP/HTTPS)内容

下面是我们给出的一个简单的例子用来访问某个页面

* Created on 2003-12-14 by Liudong

package http.demo;

import java.io.IOException;

import org.apache.commons.httpclient.*;

import org.apache.commons.httpclient.methods.*;

/**

* 最简单的HTTP客户端,用来演示通过GET或者POST方式访问某个页面

* @author Liudong

public class SimpleClient {

public static void main(String[] args) throws IOException

{

HttpClient client = new HttpClient();

//设置代理服务器地址和端口

//client.getHostConfiguration().setProxy("proxy_host_addr",proxy_port);

//使用GET方法，如果服务器需要通过HTTPS连接，那只需要将下面URL中的http换成https

HttpMethod method = new GetMethod("http://java.sun.com");

//使用POST方法

//HttpMethod method = new PostMethod("http://java.sun.com");

client.executeMethod(method);

//打印服务器返回的状态

System.out.println(method.getStatusLine());

//打印返回的信息

System.out.println(method.getResponseBodyAsString());

//释放连接

method.releaseConnection();

}
}

在这个例子中首先创建一个HTTP客户端(HttpClient)的实例，然后选择提交的方法是GET或者POST，最后在HttpClient实例上执行提交的方法，最后从所选择的提交方法中读取服务器反馈回来的结果。这就是使用HttpClient的基本流程。其实用一行代码也就可以搞定整个请求的过程，非常的简单！

(浏览全文引用此文)
文章来源:http://www.blogcn.com/user28/reene/blog/22216549.html

快乐着飞舞着 2005-10-09 13:07 发表评论

有用的国外开源项目网址 [转]

快乐着飞舞着 — Sun, 09 Oct 2005 05:07:00 GMT

sourceforge http://www.sourceforge.net
java.net http://www.java.net

www.eclipse.org

www.opensource.org

(5)几个常用JAVA开源项目的地址荟萃:
Lomboz      http://www.objectlearn.com/index.jsp (J2EE plugin for Eclipse)
htmlArea    http://sourceforge.net/projects/itools-htmlarea/ (所见即所得的在线HTML编辑器)
XmlBuddy   http://www.xmlbuddy.com/ (XML Editor plugin for Eclipse)
JFreeChart http://www.jfree.org/ (用于生成图表的项目)
EclipseME   http://eclipseme.sourceforge.net/ (J2ME Developmnt Plugin for Eclipse)
mvnForum http://sourceforge.net/projects/mvnforum/ (论坛)
jChatBox    http://www.javazoom.net/index.shtml (用servlet实现的WEB聊天引擎)
POI            http://jakarta.apache.org/poi/index.html (用于处理Excel,WORD等文档的项目)
FileUpload http://jakarta.apache.org/commons/fileupload/ (用于处理HTTP文件上传得项目)
PDFBox      http://sourceforge.net/projects/pdfbox/ (处理PDF文档的项目)
Lucene      http://jakarta.apache.org/lucene/index.html (搜索引擎)
Digester    http://jakarta.apache.org/commons/digester/ (处理XML信息的项目)
DBCP         http://jakarta.apache.org/commons/dbcp/ (数据库连接池)
AXIS          http://ws.apache.org/axis/ (WebService 的实现框架)
Jetspeed   http://portals.apache.org/jetspeed-1/ (Portal)
HSQLDB    http://sourceforge.net/projects/hsqldb/ (Im memory Database Engine)
CEWOLF   http://sourceforge.net/projects/cewolf/ (一套标签库实现Web报表,使用的是jFreeChart引擎)
Struts Menu http://sourceforge.net/projects/struts-menu/ (基于Struts的Web菜单项目)
htmlparser   http://sourceforge.net/projects/htmlparser/   (用于解析HTML信息的项目)
Mondrian     http://sourceforge.net/projects/mondrian/ (Open Source OLAP Database)
ProGuard     http://sourceforge.net/projects/proguard/ (Java的混淆器)
InfoGlue      http://sourceforge.net/projects/infoglue/ (J2EE 内容管理系统)
JPivot          http://sourceforge.net/projects/jpivot/ (基于WEB的OLAP 展现)
HttpClient   http://jakarta.apache.org/commons/httpclient/ 处理http客户端的接口

(浏览全文引用此文)
文章来源:http://www.blogcn.com/user28/reene/blog/22215741.html

快乐着飞舞着 2005-10-09 13:07 发表评论

应用HttpClient来对付各种顽固的WEB服务器(4) [转]

快乐着飞舞着 — Sun, 09 Oct 2005 05:07:00 GMT

6．通过HTTP上传文件

httpclient使用了单独的一个HttpMethod子类来处理文件的上传，这个类就是MultipartPostMethod，该类已经封装了文件上传的细节，我们要做的仅仅是告诉它我们要上传文件的全路径即可，下面的代码片段演示如何使用这个类。

MultipartPostMethod filePost = new MultipartPostMethod(targetURL);

filePost.addParameter("fileName", targetFilePath);

HttpClient client = new HttpClient();

//由于要上传的文件可能比较大,因此在此设置最大的连接超时时间

client.getHttpConnectionManager().getParams().setConnectionTimeout(5000);

int status = client.executeMethod(filePost);

上面代码中，targetFilePath即为要上传的文件所在的路径。

7．访问启用认证的页面

我们经常会碰到这样的页面，当访问它的时候会弹出一个浏览器的对话框要求输入用户名和密码后方可，这种用户认证的方式不同于我们在前面介绍的基于表单的用户身份验证。这是HTTP的认证策略，httpclient支持三种认证方式包括：基本、摘要以及NTLM认证。其中基本认证最简单、通用但也最不安全；摘要认证是在HTTP 1.1中加入的认证方式，而NTLM则是微软公司定义的而不是通用的规范，最新版本的NTLM是比摘要认证还要安全的一种方式。

下面例子是从httpclient的CVS服务器中下载的，它简单演示如何访问一个认证保护的页面：

import org.apache.commons.httpclient.HttpClient;

import org.apache.commons.httpclient.UsernamePasswordCredentials;

import org.apache.commons.httpclient.methods.GetMethod;

public class BasicAuthenticationExample {

public BasicAuthenticationExample() {

}

public static void main(String[] args) throws Exception {

HttpClient client = new HttpClient();

client.getState().setCredentials(

"www.verisign.com",

"realm",

new UsernamePasswordCredentials("username", "password")

);

GetMethod get = new GetMethod("https://www.verisign.com/products/index.html");

get.setDoAuthentication( true );

int status = client.executeMethod( get );

System.out.println(status+"\n"+ get.getResponseBodyAsString());

get.releaseConnection();

}

8．多线程模式下使用httpclient

多线程同时访问httpclient，例如同时从一个站点上下载多个文件。对于同一个HttpConnection同一个时间只能有一个线程访问，为了保证多线程工作环境下不产生冲突，httpclient使用了一个多线程连接管理器的类：MultiThreadedHttpConnectionManager，要使用这个类很简单，只需要在构造HttpClient实例的时候传入即可，代码如下：

MultiThreadedHttpConnectionManager connectionManager =

new MultiThreadedHttpConnectionManager();

HttpClient client = new HttpClient(connectionManager);

以后尽管访问client实例即可。

参考资料：

httpclient首页： http://jakarta.apache.org/commons/httpclient/
关于NTLM是如何工作： http://davenport.sourceforge.net/ntlm.html

(浏览全文引用此文)
文章来源:http://www.blogcn.com/user28/reene/blog/22216776.html

快乐着飞舞着 2005-10-09 13:07 发表评论

jfree中字体的调整

快乐着飞舞着 — Sun, 09 Oct 2005 05:07:00 GMT

JFreeChart chart = ChartFactory.createVerticalBarChart3D(title, domain, range, dataset,true,true,false);

chart.setBackgroundPaint(new GradientPaint(0.0F, 0.0F, Color.white, 1000F, 0.0F, Color.red));
chart.setTitle(new TextTitle(title, new Font("隶书", Font.ITALIC, 15)));

Font font=new Font("黑体",Font.TRUETYPE_FONT, 12);

StandardLegend legend = (StandardLegend) chart.getLegend();
legend.setItemFont(font);

CategoryPlot plot = (CategoryPlot)chart.getPlot();
plot.setForegroundAlpha(0.9F);

CategoryAxis domain_axis = plot.getDomainAxis();
domain_axis.setTickLabelFont(font);

ValueAxis value_axis=plot.getRangeAxis();
value_axis.setTickLabelFont(font);

(浏览全文引用此文)
文章来源:http://www.blogcn.com/user28/reene/blog/22155047.html

快乐着飞舞着 2005-10-09 13:07 发表评论

使用JFreeChart创建图象

快乐着飞舞着 — Sun, 09 Oct 2005 05:07:00 GMT

使用JFreeChart创建图象
文档性质：转载发表时间：2003-5-21 快速返回
作者:孤魂一笑(bingo_ge@hotmail.com) 日期：2003-05-08
一：jfreechart介绍
jfreechart是一个免费创建图片的java工具.可以创建如下图形：
饼图(pie charts;)
曲线图(line charts )
柱状图(horizontal/vertical bar charts)
甘特图(Gantt charts; )
XY plots and scatter plots;
time series, high/low/open/close charts and candle stick charts;
combination charts;
Pareto charts;
bubble charts;
wind plots, meter charts and symbol charts;
从以下地址可以看到jfreechart可以创建的图形类型
http://www.jfree.org/jfreechart/samples.html
sourceforge有一个基于jfreechart的项目Cewolf可以很方便的在jsp/servlet中创建图片
jfreechart目前(2003-05-08)版本为0.98
希望得到详细的信息或下载jfreechart请访问如下站点:
http://www.jfree.org/jfreechart/

二：特别说明:
jfreechart是一个开源项目，但是文档是需要40美金去购买的。
还有一个很重要的问题,jfreechart如果使用中文，他使用的默认字体
显示出来的中文会很模糊，你可能需要修改源代码。
下面我就举几个简单的例子说明一下如何使用jfreechart创建图片
在开发中有可能会导入以下的类
import com.jrefinery.chart.ChartFactory;
import com.jrefinery.chart.ChartUtilities;
import com.jrefinery.chart.JFreeChart;
import com.jrefinery.chart.TextTitle;
import com.jrefinery.chart.axis.NumberAxis;
import com.jrefinery.chart.plot.CategoryPlot;
import com.jrefinery.chart.plot.PiePlot;
import com.jrefinery.data.Day;
import com.jrefinery.data.DefaultCategoryDataset;
import com.jrefinery.data.DefaultPieDataset;
import com.jrefinery.data.TimeSeries;
import com.jrefinery.data.TimeSeriesCollection;
import com.jrefinery.data.TimeSeriesDataPair;
在0.98以后包由com.jrefinery.*改变为:org.jfree

三：创建饼图
//图片标题
String title = "空调2002年市场占有率";
//设定数据源
DefaultPieDataset piedata = new DefaultPieDataset();
//第一个参数为名称，第二个参数是double数
piedata.setValue("联想", 27.3);
piedata.setValue("长城", 12.2);
piedata.setValue("海尔", 5.5);
piedata.setValue("美的", 17.1);
piedata.setValue("松下", 9.0);
piedata.setValue("科龙", 19.0);
//创建JFreeChart，都使用ChartFactory来创建JFreeChart,很标准的工厂设计模式
JFreeChart chart =
ChartFactory.createPieChart(title, piedata, true, true, true);
//设定图片标题
chart.setTitle(new TextTitle(title, new Font("隶书", Font.ITALIC, 15)));
//chart.addSubtitle(new TextTitle("2002财年分析", new Font("隶书", Font.ITALIC, 12)));
//设定背景
chart.setBackgroundPaint(Color.white);
//chart.s
//饼图使用一个PiePlot
PiePlot pie = (PiePlot)chart.getPlot();
//pie.setSectionLabelType(PiePlot.NAME_AND_PERCENT_LABELS);
pie.setSectionLabelType(PiePlot.NAME_AND_VALUE_LABELS);
//设定显示格式(名称加百分比或数值)
pie.setPercentFormatString("#,###0.0#%");
//设定百分比显示格式
pie.setBackgroundPaint(Color.white);
pie.setSectionLabelFont(new Font("黑体", Font.TRUETYPE_FONT, 12));
//设定背景透明度（0-1.0之间）
pie.setBackgroundAlpha(0.6f);
//设定前景透明度（0-1.0之间）
pie.setForegroundAlpha(0.90f);
//输出文件到指定目录
String rfname = MathUtil.getRoundCode(12) + ".jpeg";
String fileName = "d:/test/" + rfname;
try {
//可以保存文件为jpg或png格式。
ChartUtilities.saveChartAsJPEG(new File(fileName), 100, chart, 600, 600);
//第一个参数为文件名
//第二个参数质量
//第三个参数为哪个chart创建图片
//第四个宽度
//第五个高度
} catch (IOException exz) {
System.out.print("....Cant’t Create image File");
}

其实使用JFreeChart创建图片很简单，不同的的图片类型区别在于设置数据集

四：创建曲线图
// create a default chart based on some sample data...
//曲线图标题
String title = "趋势分析";
//曲线图X轴提示
String domain = "月份走势";
//曲线图Y轴提示
String range = "应收余额";
//曲线图自标题
String subtitleStr = "2003财年分析";
//创建时间数据源
//每一个TimeSeries在图上是一条曲线
TimeSeries ca = new TimeSeries("用友");
for (int i = 1999; i < 2005; i++) {
for (int mon = 0; mon < 12; mon++) {
//ca.add(new Month(mon + 1, i), new Double(500 + Math.random() * 100));
//TimeSeriesDataPair是一个时间点的数值体现
ca.add(
new TimeSeriesDataPair(
new Day(1, mon + 1, i),
new Double(500 + Math.random() * 100)));
}
}

TimeSeries ibm = new TimeSeries("金碟");
for (int i = 1999; i < 2005; i++) {
for (int mon = 0; mon < 12; mon++) {
//ibm.add(new Month(mon+1,i),new Double(400-Math.random()*100));
ibm.add(
new TimeSeriesDataPair(
new Day(1, mon + 1, i),
new Double(400 - Math.random() * 100)));
}
}

TimeSeries king = new TimeSeries("东软");
for (int i = 1999; i < 2005; i++) {
for (int mon = 0; mon < 12; mon++) {
//ibm.add(new Month(mon+1,i),new Double(400-Math.random()*100));
king.add(
new TimeSeriesDataPair(
new Day(1, mon + 1, i),
new Double(300 - Math.random() * 100)));
}
}
//时间曲线数据集合
TimeSeriesCollection dataset = new TimeSeriesCollection();
dataset.addSeries(ca);
dataset.addSeries(ibm);
dataset.addSeries(king);
//dataset.addSeries(jpy);
//dataset.addSeries(mav);
//时间曲线元素
JFreeChart chart =
ChartFactory.createTimeSeriesChart(
title,
domain,
range,
dataset,
true,
true,
false);
// then customise it a little...
TextTitle subtitle =
new TextTitle(subtitleStr, new Font("黑体", Font.BOLD, 12));
chart.addSubtitle(subtitle);
chart.setTitle(new TextTitle(title, new Font("隶书", Font.ITALIC, 15)));
//pie.setSeriesLabelFont(new Font("黑体", Font.BOLD, 15));
chart.setBackgroundPaint(
new GradientPaint(0, 0, Color.white, 0, 1000, Color.blue));
//sysout
//输出文件到指定目录
String rfname = MathUtil.getRoundCode(22) + ".jpeg";
String fileName = "d:/test/" + rfname;
try {
//for
//System.out.println();
ChartUtilities.saveChartAsJPEG(new File(fileName), 100, chart, 600, 600);
// log.info("....Create image File:" + fileName);
} catch (IOException exz) {
System.out.print("....Cant’t Create image File");
}

五：创建柱状图
String title = "柱状图测试";
String domain = "单位比较";
String range = "数值";
//CategoryDataset data = DemoDatasetFactory.createCategoryDataset();
DefaultCategoryDataset data = new DefaultCategoryDataset();
for (int r = 0; r < 5; r++) {
String rowKey = "单位 [" + (r + 1)+"]" ;
//第一层循环：分析对象
for (int c = 0; c < 6; c++) {
//第二层循环：分析对象在时间点上的数据
String columnKey = "2001年" + (c + 1) + "月";
data.addValue(new Double(r * c + 5), rowKey, columnKey);
}
}

JFreeChart chart =
ChartFactory.createVerticalBarChart(
title,
domain,
range,
data,
true,
true,
false);
// then customise it a little...
chart.setBackgroundPaint(
new GradientPaint(0, 0, Color.white, 1000, 0, Color.red));
chart.setTitle(new TextTitle(title, new Font("隶书", Font.ITALIC, 15)));
CategoryPlot plot = (CategoryPlot)chart.getPlot();
plot.setForegroundAlpha(0.9f);
plot.setValueLabelFont(new Font("黑体", Font.TRUETYPE_FONT, 12));
//plot.setSectionLabelFont(new Font("黑体", Font.TRUETYPE_FONT, 12));
//注意以下代码
NumberAxis verticalAxis = (NumberAxis)plot.getRangeAxis();
verticalAxis.setStandardTickUnits(NumberAxis.createIntegerTickUnits());
// 输出文件到指定目录
String rfname = MathUtil.getRoundCode(22) + "b.jpeg";
String fileName = "d:/test/" + rfname;
try {
ChartUtilities.saveChartAsJPEG(new File(fileName), 100, chart, 600, 600);
// log.info("....Create image File:" + fileName);
} catch (IOException exz) {
System.out.print("....Cant’t Create image File");
}

六：结束语
个人感觉JFreeChart可以满足大部分图片创建的需要，美中不足的是：对字体的设置做的
不够好，特别是使用中文的时候字体很不清晰。因为这个原因建议你自己去修改他的源代码
最好使用properties文件去设置字体.还有就是文档要钱所以要多花点时间去看源代码。或多
上社区.因为时间等原因我只介绍了三种图片的创建，其他类型的图片可以参考jfreechart提
供的例子。

(浏览全文引用此文)
文章来源:http://www.blogcn.com/user28/reene/blog/22154859.html

快乐着飞舞着 2005-10-09 13:07 发表评论

在eclipse+myeclipse+weblogic下EJB开发所要注意的问题 [转]

快乐着飞舞着 — Sun, 09 Oct 2005 05:07:00 GMT

一般在使用ejb时都是从创立J2EE项目的application项中依次创建application，ejb,web三项，其中：
appliction是用来作为j2ee部署时使用的。
ejb就是创建ejb组件。
web就是一个web服务的容器，包括hrml,jsp,servlet,struts等。
在myeclipse中使用EJB的两种方法：
1）选择J2EE1.3则可以通过xDoclet来根据app_bean来生成app,home,session,apputil等。
2）选择J2EE1.4的就需要自己写app,home,sesion等程序代码。
对于整个程序以后的运行过程都是以JNDI为主线的展开，要注意：
一般要以home中的jndi-name为标准，具体在使用xdoclet的j2ee1.3时参看相关的帮助。
配置主要在：weblogic-ejb-jar.xml和ejb-jar.xml的jndi的设置。(这一般是针对于在同一服务器内部的jndi的调用，而对于其他外部情况，需要设置ervirament,权限等问题后才能进行lookup)
由于在服务器等各方面的原因,在部署之前要注意几个配置文件的正确的位置:
1) weblogic-ejb-jar.xml和ejb-jar.xml要在XXXEJB/src/meta-inf下，可以通过在不同的目录下导入。
2) web.xml和weblogic.xml要在XXXWeb/webRoot/web-inf下，可以weblogic.xml直接用别的程序的，web.xml需要自己根据需要来配置。
最后在部署之前，要对整个application server的三项进行项目清理，然后部署到服务器上。

(浏览全文引用此文)
文章来源:http://www.blogcn.com/user28/reene/blog/21696707.html

快乐着飞舞着 2005-10-09 13:07 发表评论

昨天做梦都在写代码

快乐着飞舞着 — Sun, 09 Oct 2005 05:07:00 GMT

昨天一天都在写xdoclet 结果今天早上起床时就记得点了一夜的鼠标写了一夜的代码

(浏览全文引用此文)
文章来源:http://www.blogcn.com/user28/reene/blog/22038480.html

快乐着飞舞着 2005-10-09 13:07 发表评论

使用 JFreeChart来创建基于web的图表（1）

快乐着飞舞着 — Sun, 09 Oct 2005 05:07:00 GMT

关于jfreechart的介绍和配置部分就省去。

下面我们来介绍JFreeChart中几个核心的对象类：

类名	类的作用以及简单描述
JFreeChart	图表对象，任何类型的图表的最终表现形式都是在该对象进行一些属性的定制。JFreeChart引擎本身提供了一个工厂类用于创建不同类型的图表对象
XXXXXDataset	数据集对象，用于提供显示图表所用的数据。根据不同类型的图表对应着很多类型的数据集对象类
XXXXXPlot	图表区域对象，基本上这个对象决定着什么样式的图表，创建该对象的时候需要Axis、Renderer以及数据集对象的支持
XXXXXAxis	用于处理图表的两个轴：纵轴和横轴
XXXXXRenderer	负责如何显示一个图表对象
XXXXXURLGenerator	用于生成Web图表中每个项目的鼠标点击链接
XXXXXToolTipGenerator	用于生成图象的帮助提示，不同类型图表对应不同类型的工具提示类

· 使用JFreeChart生成各种样式的图表

限于篇幅的问题我们在这里只实现两种常用的图表，其他类型图表读者可以触类旁通。我们先给出柱状图的实现，饼图的实现再来跟柱状图进行比较。

· 1 柱状图

package lius.chart.demo;

import java.io.*;

import org.jfree.data.*;
import org.jfree.chart.*;
import org.jfree.chart.plot.*;
/**
* 该类用于演示最简单的柱状图生成
* @author Winter Lau
*/
public class BarChartDemo {

public static void main(String[] args) throws IOException{

CategoryDataset dataset = getDataSet2();
JFreeChart chart = ChartFactory.createBarChart3D(
"水果产量图", // 图表标题
"水果", // 目录轴的显示标签
"产量", // 数值轴的显示标签
dataset, // 数据集
PlotOrientation.VERTICAL, // 图表方向：水平、垂直
true, // 是否显示图例(对于简单的柱状图必须是false)
false, // 是否生成工具
false // 是否生成URL链接
);

FileOutputStream fos_jpg = null;
try {
fos_jpg = new FileOutputStream("D:\\fruit.jpg");
ChartUtilities.writeChartAsJPEG(fos_jpg,100,chart,400,300,null);
} finally {
try {
fos_jpg.close();
} catch (Exception e) {}
}
}
/**
* 获取一个演示用的简单数据集对象
* @return
*/
private static CategoryDataset getDataSet() {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
dataset.addValue(100, null, "苹果");
dataset.addValue(200, null, "梨子");
dataset.addValue(300, null, "葡萄");
dataset.addValue(400, null, "香蕉");
dataset.addValue(500, null, "荔枝");
return dataset;
}
/**
* 获取一个演示用的组合数据集对象
* @return
*/
private static CategoryDataset getDataSet2() {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
dataset.addValue(100, "北京", "苹果");
dataset.addValue(100, "上海", "苹果");
dataset.addValue(100, "广州", "苹果");
dataset.addValue(200, "北京", "梨子");
dataset.addValue(200, "上海", "梨子");
dataset.addValue(200, "广州", "梨子");
dataset.addValue(300, "北京", "葡萄");
dataset.addValue(300, "上海", "葡萄");
dataset.addValue(300, "广州", "葡萄");
dataset.addValue(400, "北京", "香蕉");
dataset.addValue(400, "上海", "香蕉");
dataset.addValue(400, "广州", "香蕉");
dataset.addValue(500, "北京", "荔枝");
dataset.addValue(500, "上海", "荔枝");
dataset.addValue(500, "广州", "荔枝");
return dataset;
}
}

程序运行结束后生成的图片文件效果如下图所示：

图4

如果是使用简单的数据即使用getDataSet方法获取数据集时产生的图片文件如下：

图5

(浏览全文引用此文)
文章来源:http://www.blogcn.com/user28/reene/blog/22124837.html

快乐着飞舞着 2005-10-09 13:07 发表评论

使用 JFreeChart来创建基于web的图表（2）

快乐着飞舞着 — Sun, 09 Oct 2005 05:07:00 GMT

· 2 饼图

对于饼图而言，数据集的获取用的不是同一个数据集类，另外饼图不支持同一个类别的项目中还有子项目这样的数据。我们只给出创建饼图的代码，至于写图表到一个文件则与柱状图一致，无需重复。

package lius.chart.demo;

import java.io.*;

import org.jfree.data.*;
import org.jfree.chart.*;
/**
* 用于演示饼图的生成
* @author Winter Lau
*/
public class PieChartDemo {

public static void main(String[] args) throws IOException{
DefaultPieDataset data = getDataSet();
JFreeChart chart = ChartFactory.createPie3DChart("水果产量图", // 图表标题
data,
true, // 是否显示图例
false,
false
);
//写图表对象到文件，参照柱状图生成源码
}
/**
* 获取一个演示用的简单数据集对象
* @return
*/
private static DefaultPieDataset getDataSet() {
DefaultPieDataset dataset = new DefaultPieDataset();
dataset.setValue("苹果",100);
dataset.setValue("梨子",200);
dataset.setValue("葡萄",300);
dataset.setValue("香蕉",400);
dataset.setValue("荔枝",500);
return dataset;
}
}

生成的饼图文件效果如下：

图6

将生成的图表移到浏览器上
为了将生成的图表直接传给客户端浏览器，只需要将前面两个例子中的文件流换成是通过HttpServletResponse对象获取到的输出流，详细代码清单如下：

package lius.chart.demo;

import java.io.IOException;
import javax.servlet.*;
import javax.servlet.http.HttpServlet;

import org.jfree.data.*;
import org.jfree.chart.*;
/**
* 演示通过servlet直接输出图表
* @author Winter Lau
*/
public class ChartDemoServlet extends HttpServlet {

public void service(ServletRequest req, ServletResponse res)
throws ServletException, IOException
{
res.setContentType("image/jpeg");
DefaultPieDataset data = getDataSet();
JFreeChart chart = ChartFactory.createPie3DChart("水果产量图",
data,
true,
false,
false
);

ChartUtilities.writeChartAsJPEG(res.getOutputStream(),
100,chart,400,300,null);
}
/**
* 获取一个演示用的简单数据集对象
* @return
*/
private static DefaultPieDataset getDataSet() {
DefaultPieDataset dataset = new DefaultPieDataset();
dataset.setValue("苹果",100);
dataset.setValue("梨子",200);
dataset.setValue("葡萄",300);
dataset.setValue("香蕉",400);
dataset.setValue("荔枝",500);
return dataset;
}
}

(浏览全文引用此文)
文章来源:http://www.blogcn.com/user28/reene/blog/22124929.html

快乐着飞舞着 2005-10-09 13:07 发表评论

用Java Swing制作欢迎屏幕(2)

快乐着飞舞着 — Sun, 09 Oct 2005 05:07:00 GMT

现在我们有了一个很不错的欢迎屏幕，它可以通过点击的方法关闭，但它不会自己消失。接下来我们要加入代码，使得欢迎屏幕在显示一定的时间之后自动消失。这里我们要考虑到运用线程。

class SplashWindow3 extends JWindow
{
　public SplashWindow3(String filename, Frame f, int waitTime)
　{
　　super(f);
　　JLabel l = new JLabel(new ImageIcon(filename));
　　getContentPane().add(l, BorderLayout.CENTER);
　　pack();
　　Dimension screenSize =Toolkit.getDefaultToolkit().getScreenSize();
　　Dimension labelSize = l.getPreferredSize();
　　setLocation(screenSize.width/2 - (labelSize.width/2),
　　screenSize.height/2 - (labelSize.height/2));
　　addMouseListener(new MouseAdapter()
　　{
　　　public void mousePressed(MouseEvent e)
　　　{
　　　　setVisible(false);
　　　　dispose();
　　　}
　　});
　　final int pause = waitTime;
　　final Runnable closerRunner = new Runnable()
　　{
　　　public void run()
　　　{
　　　　setVisible(false);
　　　　dispose();
　　　}
　　};
　　Runnable waitRunner = new Runnable()
　　{
　　　public void run()
　　　{
　　　　try
　　　　{
　　　　　Thread.sleep(pause);
　　　　　SwingUtilities.invokeAndWait(closerRunner);
　　　　}
　　　　catch(Exception e)
　　　　{
　　　　　e.printStackTrace();
　　　　　// 能够捕获InvocationTargetException
　　　　　// 能够捕获InterruptedException
　　　　}
　　　}
　　};
　　setVisible(true);
　　Thread splashThread = new Thread(waitRunner, "SplashThread");
　　splashThread.start();
　}
}

　　这里的基本思路是利用一个在一定时间内暂停等待的Thread对象。在上面的代码中，线程的暂停时间是4秒。当这个线程唤醒时，它将关闭欢迎屏幕。由于Swing是非线程安全的，除非代码在事件分派线程上执行，否则它就不应该影响任何UI组件的状态。所谓事件分派线程，就是Swing中负责绘图和事件处理的线程。

　　为了解决这个问题，Swing设计者赋予我们安全地把Runnable对象加入UI事件队列的能力。在本例中，我们用可运行对象closerRunner完成最关键的工作。我们把可运行对象传入SwingUtilities.invokeAndWait()静态方法，然后wingUtilities.invokeAndWait()进行所有未完成的UI操作，并执行传递给该方法的可运行对象closerRunner的run方法。通过运用一个独立的线程负责欢迎屏幕的关闭操作，应用担负起了显示和关闭欢迎屏幕之间的所有操作。

　　如果要让欢迎屏幕总是显示且用户不能关闭它，你必须删除那些隐藏欢迎屏幕的代码。如果要让欢迎屏幕只能由用户手工关闭，你可以象使用任何其他JWindow对象一样调用SplashWindow3对象上的setVisible(false)和dispose()方法。

(浏览全文引用此文)
文章来源:http://www.blogcn.com/user28/reene/blog/22125464.html

快乐着飞舞着 2005-10-09 13:07 发表评论

用Java Swing制作欢迎屏幕(1) [转]

快乐着飞舞着 — Sun, 09 Oct 2005 05:07:00 GMT

几乎所有时髦的应用都有一个欢迎屏幕。欢迎屏幕既是宣传产品的方法之一，而且在长时间的应用启动过程中，欢迎屏幕还用来表示应用正在准备过程中。

　　下面是一个最简单的欢迎屏幕实现：

class SplashWindow1 extends JWindow
{
　public SplashWindow1(String filename, Frame f)
　{
　　super(f);
　　JLabel l = new JLabel(new ImageIcon(filename));
　　getContentPane().add(l, BorderLayout.CENTER);
　　pack();
　　Dimension screenSize =Toolkit.getDefaultToolkit().getScreenSize();
　　Dimension labelSize = l.getPreferredSize();
　　setLocation(screenSize.width/2 - (labelSize.width/2),
　　screenSize.height/2 - (labelSize.height/2));
　　setVisible(true);
　　screenSize = null;
　　labelSize = null;
　}
}

　　SplashWindow1类从Swing的JWindow派生。JWindow是一个容器，它没有其他窗口所具有的各种窗口元素，如标题条、窗口管理按钮，甚至连突出显示的边框也没有。因此，JWindow对于制作欢迎屏幕来说是非常合适的。上面的代码假定图形文件在当前目录。图形通过ImageIcon装入内存，然后它就被放到了JWindow的中心。接着，窗口被pack()，这使得Swing把窗口调整到适当的大小，最后窗口被移到了屏幕的中心。

　　如果我们运行上面的程序，可以发现虽然欢迎画面确实出现在屏幕中央，但遗憾的，它却不会关闭！要关闭欢迎画面，我们需要加入更多的代码：

class SplashWindow2 extends JWindow
{
　public SplashWindow2(String filename, Frame f)
　{
　　super(f);
　　JLabel l = new JLabel(new ImageIcon(filename));
　　getContentPane().add(l, BorderLayout.CENTER);
　　pack();
　　Dimension screenSize =Toolkit.getDefaultToolkit().getScreenSize();
　　Dimension labelSize = l.getPreferredSize();
　　setLocation(screenSize.width/2 - (labelSize.width/2),
　　screenSize.height/2 - (labelSize.height/2));
　　addMouseListener(new MouseAdapter()
　　{　　
　　　public void mousePressed(MouseEvent e)
　　　{
　　　　setVisible(false);
　　　　dispose();
　　　}
　　});
　　setVisible(true);
　}
}

　　和原先的SplashWindow1类相比，这个SplashWindow2类唯一的区别在于多出了一个安装到JWindow上的匿名MouseListener。经过这个改动之后，用户可以点击欢迎屏幕关闭它。

(浏览全文引用此文)
文章来源:http://www.blogcn.com/user28/reene/blog/22125419.html

快乐着飞舞着 2005-10-09 13:07 发表评论

使用 JFreeChart来创建基于web的图表（3）

快乐着飞舞着 — Sun, 09 Oct 2005 05:07:00 GMT

很多情况我们不仅仅要求可以在浏览器上显示一个图表，我们更需要客户可以直接在图表上做一下交互的操作，例如获取信息提示，点击图表某个部分进行更详细信息的展示等等。例如前面生成的简单柱状图，用户需要在看到柱状图后点击某种水果例如是苹果即可看到各个地区苹果产量的情况。为此就要求该图形具有交互操作的功能。在HTML中为了让一个图像具有可交互的功能就必须给该图像定义一个Map对象。下表节选一段具有该功能的HTML代码

onclick="javascript:clickChart('100');return false;">
onclick="javascript: clickChart ('200');return false;">
onclick="javascript: clickChart ('300');return false;">
onclick="javascript: clickChart ('400');return false;">

由此就产生了一个问题：如果根据一个图像来生成对应的MAP对象。我们回头看看刚才的代码，在创建一个图表对象时候有两个参数，我们举柱状图的例子来讲这两个参数就是ChartFactory. createBarChart3D方法中的最后两个参数，这两个参数的类型都是布尔值。这两个参数意思分别是：是否创建工具提示(tooltip)以及是否生成URL。这两个参数分别对应着MAP中一个AREA的title属性以及href属性。

可是我想知道的是怎么来产生这个MAP啊！哈哈，不要着急，JFreeChart已经帮我们做好生成MAP对象的功能。为了生成MAP对象就要引入另外一个对象：ChartRenderingInfo。因为JFreeChart没有直接的方法利用一个图表对象直接生成MAP数据，它需要一个中间对象来过渡，这个对象就是ChartRenderingInfo。下图是生成MAP数据的流程图：

图7

如上图所示，ChartUtilities类是整个流程的核心，它周围的对象都是一些例如数据对象或者是文件等。这个流程简单描述如下：首先创建一个ChartRenderingInfo对象并在调用ChartUtilities的writeChartAsJPEG时作为最后一个参数传递进去。调用该方法结束后将产生一个图像文件以及一个填充好MAP数据的ChartRenderingInfo对象，有了这个对象我们还是没有办法获取具体的MAP数据，我们还必须借助于ChartUtilities的writeImageMap方法来将ChartRenderingInfo对象读取出来，获取MAP数据的代码片断如下：

PrintWriter w = null;
FileOutputStream fos_jpg = null;
FileOutputStream fos_cri = null;
try{
//根据不同类型的图表使用不同类，以下是针对饼图的操作
PiePlot plot = (PiePlot) chart.getPlot();
plot.setURLGenerator(new StandardPieURLGenerator(url));
//设置工具提示
plot.setToolTipGenerator(new StandardPieToolTipGenerator());
fos_jpg = new FileOutputStream(“d:\\fruit.jpg”);
ChartUtilities.writeChartAsJPEG(
fos_jpg,
100,
chart,
400,
300,
info);
fos_cri = new FileOutputStream(__d:\\fruit.map__);
w = new PrintWriter(fos_cri);
ChartUtilities.writeImageMap(w, __mapname__, info);
w.flush();
}finally{
try{
w.close();
}catch(Exception e){}
try{
fos_cri.close();
}catch(Exception e){}
try{
fos_jpg.close();
}catch(Exception e){}
}

打开文件D:\fruit.map，文件的内容就是要写到页面上的MAP数据。把生成的图像文件以及MAP数据文件写到页面上即可完成热点图表的功能。至于怎么结合两者之间的关系例如图像的useMap属性值必须与MAP对象的名称结合起来，必须根据实际的应用情况进行相应的处理。笔者建议把二者通过标签库封装起来，图像文件的名称以及MAP对象的名称由标签库统一进行控制，这样可以保证二者的一致性。

关于作者
刘冬，他已经不再叫凤梨罐头了。珠海市创我科技发展有限公司软件工程师，主要从事在J2EE平台上实现商业智能（BI）方面的开发。
联系电话：0756-3377435-383
电子邮件： winter.lau@163.com

(浏览全文引用此文)
文章来源:http://www.blogcn.com/user28/reene/blog/22125000.html

快乐着飞舞着 2005-10-09 13:07 发表评论

JFreeChart实时曲线(代码) [zz]

快乐着飞舞着 — Wed, 07 Sep 2005 08:02:00 GMT

摘要: 1 2 package com.cityinforport.demo; 3 /** 4 * ============================================================= ... 阅读全文

快乐着飞舞着 2005-09-07 16:02 发表评论

Java读取文件中含有中文的解决办法

快乐着飞舞着 — Wed, 17 Aug 2005 03:29:00 GMT

1
2         String b="";
3         String tmp=null;
4         try {
5             File f=new File("F:\\Eclipse\\MobileChart\\sms");
6             InputStreamReader isr= new InputStreamReader(new FileInputStream(f),"gb2312");
7             BufferedReader br=new BufferedReader(isr);
8             while((tmp=br.readLine())!=null)
9             {
10                 b+=tmp;
11             }
12         }catch(Exception e){
13             e.printStackTrace();
14         }

如上面代码所示只要指定编码形式就行了

快乐着飞舞着 2005-08-17 11:29 发表评论

Java正则表达式详解[转载]

快乐着飞舞着 — Tue, 16 Aug 2005 02:23:00 GMT

Java正则表达式详解

仙人掌工作室

01-7-31 下午 04:13:03

如果你曾经用过Perl或任何其他内建正则表达式支持的语言，你一定知道用正则表达式处理文本和匹配模式是多么简单。如果你不熟悉这个术语，那么“正则表达式”（Regular Expression）就是一个字符构成的串，它定义了一个用来搜索匹配字符串的模式。

许多语言，包括Perl、PHP、Python、JavaScript和JScript，都支持用正则表达式处理文本，一些文本编辑器用正则表达式实现高级“搜索-替换”功能。那么Java又怎样呢？本文写作时，一个包含了用正则表达式进行文本处理的Java规范需求（Specification Request）已经得到认可，你可以期待在JDK的下一版本中看到它。

然而，如果现在就需要使用正则表达式，又该怎么办呢？你可以从Apache.org下载源代码开放的Jakarta-ORO库。本文接下来的内容先简要地介绍正则表达式的入门知识，然后以Jakarta-ORO API为例介绍如何使用正则表达式。

一、正则表达式基础知识

我们先从简单的开始。假设你要搜索一个包含字符“cat”的字符串，搜索用的正则表达式就是“cat”。如果搜索对大小写不敏感，单词“catalog”、“Catherine”、“sophisticated”都可以匹配。也就是说：

1.1 句点符号

假设你在玩英文拼字游戏，想要找出三个字母的单词，而且这些单词必须以“t”字母开头，以“n”字母结束。另外，假设有一本英文字典，你可以用正则表达式搜索它的全部内容。要构造出这个正则表达式，你可以使用一个通配符——句点符号“.”。这样，完整的表达式就是“t.n”，它匹配“tan”、“ten”、“tin”和“ton”，还匹配“t#n”、“tpn”甚至“t n”，还有其他许多无意义的组合。这是因为句点符号匹配所有字符，包括空格、Tab字符甚至换行符：

1.2 方括号符号

为了解决句点符号匹配范围过于广泛这一问题，你可以在方括号（“[]”）里面指定看来有意义的字符。此时，只有方括号里面指定的字符才参与匹配。也就是说，正则表达式“t[aeio]n”只匹配“tan”、“Ten”、“tin”和“ton”。但“Toon”不匹配，因为在方括号之内你只能匹配单个字符：

1.3 “或”符号

如果除了上面匹配的所有单词之外，你还想要匹配“toon”，那么，你可以使用“|”操作符。“|”操作符的基本意义就是“或”运算。要匹配“toon”，使用“t(a|e|i|o|oo)n”正则表达式。这里不能使用方扩号，因为方括号只允许匹配单个字符；这里必须使用圆括号“()”。圆括号还可以用来分组，具体请参见后面介绍。

1.4 表示匹配次数的符号

表一显示了表示匹配次数的符号，这些符号用来确定紧靠该符号左边的符号出现的次数：

假设我们要在文本文件中搜索美国的社会安全号码。这个号码的格式是999-99-9999。用来匹配它的正则表达式如图一所示。在正则表达式中，连字符（“-”）有着特殊的意义，它表示一个范围，比如从0到9。因此，匹配社会安全号码中的连字符号时，它的前面要加上一个转义字符“\”。

图一：匹配所有123-12-1234形式的社会安全号码

假设进行搜索的时候，你希望连字符号可以出现，也可以不出现——即，999-99-9999和999999999都属于正确的格式。这时，你可以在连字符号后面加上“？”数量限定符号，如图二所示：

图二：匹配所有123-12-1234和123121234形式的社会安全号码

下面我们再来看另外一个例子。美国汽车牌照的一种格式是四个数字加上二个字母。它的正则表达式前面是数字部分“[0-9]{4}”，再加上字母部分“[A-Z]{2}”。图三显示了完整的正则表达式。

图三：匹配典型的美国汽车牌照号码，如8836KV

1.5 “否”符号

“^”符号称为“否”符号。如果用在方括号内，“^”表示不想要匹配的字符。例如，图四的正则表达式匹配所有单词，但以“X”字母开头的单词除外。

图四：匹配所有单词，但“X”开头的除外

1.6 圆括号和空白符号

假设要从格式为“June 26, 1951”的生日日期中提取出月份部分，用来匹配该日期的正则表达式可以如图五所示：

图五：匹配所有Moth DD,YYYY格式的日期

新出现的“\s”符号是空白符号，匹配所有的空白字符，包括Tab字符。如果字符串正确匹配，接下来如何提取出月份部分呢？只需在月份周围加上一个圆括号创建一个组，然后用ORO API（本文后面详细讨论）提取出它的值。修改后的正则表达式如图六所示：

图六：匹配所有Month DD,YYYY格式的日期，定义月份值为第一个组

1.7 其它符号

为简便起见，你可以使用一些为常见正则表达式创建的快捷符号。如表二所示：

表二：常用符号

例如，在前面社会安全号码的例子中，所有出现“[0-9]”的地方我们都可以使用“\d”。修改后的正则表达式如图七所示：

图七：匹配所有123-12-1234格式的社会安全号码

二、Jakarta-ORO库

有许多源代码开放的正则表达式库可供Java程序员使用，而且它们中的许多支持Perl 5兼容的正则表达式语法。我在这里选用的是Jakarta-ORO正则表达式库，它是最全面的正则表达式API之一，而且它与Perl 5正则表达式完全兼容。另外，它也是优化得最好的API之一。

Jakarta-ORO库以前叫做OROMatcher，Daniel Savarese大方地把它赠送给了Jakarta Project。你可以按照本文最后参考资源的说明下载它。

我首先将简要介绍使用Jakarta-ORO库时你必须创建和访问的对象，然后介绍如何使用Jakarta-ORO API。

▲ PatternCompiler对象

首先，创建一个Perl5Compiler类的实例，并把它赋值给PatternCompiler接口对象。Perl5Compiler是PatternCompiler接口的一个实现，允许你把正则表达式编译成用来匹配的Pattern对象。

▲ Pattern对象

要把正则表达式编译成Pattern对象，调用compiler对象的compile()方法，并在调用参数中指定正则表达式。例如，你可以按照下面这种方式编译正则表达式“t[aeio]n”：

默认情况下，编译器创建一个大小写敏感的模式（pattern）。因此，上面代码编译得到的模式只匹配“tin”、“tan”、 “ten”和“ton”，但不匹配“Tin”和“taN”。要创建一个大小写不敏感的模式，你应该在调用编译器的时候指定一个额外的参数：

创建好Pattern对象之后，你就可以通过PatternMatcher类用该Pattern对象进行模式匹配。

▲ PatternMatcher对象

PatternMatcher对象根据Pattern对象和字符串进行匹配检查。你要实例化一个Perl5Matcher类并把结果赋值给PatternMatcher接口。Perl5Matcher类是PatternMatcher接口的一个实现，它根据Perl 5正则表达式语法进行模式匹配：

使用PatternMatcher对象，你可以用多个方法进行匹配操作，这些方法的第一个参数都是需要根据正则表达式进行匹配的字符串：

· boolean matches(String input, Pattern pattern)：当输入字符串和正则表达式要精确匹配时使用。换句话说，正则表达式必须完整地描述输入字符串。

· boolean matchesPrefix(String input, Pattern pattern)：当正则表达式匹配输入字符串起始部分时使用。

· boolean contains(String input, Pattern pattern)：当正则表达式要匹配输入字符串的一部分时使用（即，它必须是一个子串）。

另外，在上面三个方法调用中，你还可以用PatternMatcherInput对象作为参数替代String对象；这时，你可以从字符串中最后一次匹配的位置开始继续进行匹配。当字符串可能有多个子串匹配给定的正则表达式时，用PatternMatcherInput对象作为参数就很有用了。用PatternMatcherInput对象作为参数替代String时，上述三个方法的语法如下：

· boolean matches(PatternMatcherInput input, Pattern pattern)

· boolean matchesPrefix(PatternMatcherInput input, Pattern pattern)

· boolean contains(PatternMatcherInput input, Pattern pattern)

三、应用实例

下面我们来看看Jakarta-ORO库的一些应用实例。

3.1 日志文件处理

任务：分析一个Web服务器日志文件，确定每一个用户花在网站上的时间。在典型的BEA WebLogic日志文件中，日志记录的格式如下：

分析这个日志记录，可以发现，要从这个日志文件提取的内容有两项：IP地址和页面访问时间。你可以用分组符号（圆括号）从日志记录提取出IP地址和时间标记。

首先我们来看看IP地址。IP地址有4个字节构成，每一个字节的值在0到255之间，各个字节通过一个句点分隔。因此，IP地址中的每一个字节有至少一个、最多三个数字。图八显示了为IP地址编写的正则表达式：

图八：匹配IP地址

IP地址中的句点字符必须进行转义处理（前面加上“\”），因为IP地址中的句点具有它本来的含义，而不是采用正则表达式语法中的特殊含义。句点在正则表达式中的特殊含义本文前面已经介绍。

日志记录的时间部分由一对方括号包围。你可以按照如下思路提取出方括号里面的所有内容：首先搜索起始方括号字符（“[”），提取出所有不超过结束方括号字符（“]”）的内容，向前寻找直至找到结束方括号字符。图九显示了这部分的正则表达式。

图九：匹配至少一个字符，直至找到“]”

现在，把上述两个正则表达式加上分组符号（圆括号）后合并成单个表达式，这样就可以从日志记录提取出IP地址和时间。注意，为了匹配“- -”（但不提取它），正则表达式中间加入了“\s-\s-\s”。完整的正则表达式如图十所示。

图十：匹配IP地址和时间标记

现在正则表达式已经编写完毕，接下来可以编写使用正则表达式库的Java代码了。

为使用Jakarta-ORO库，首先创建正则表达式字符串和待分析的日志记录字符串：

这里使用的正则表达式与图十的正则表达式差不多完全相同，但有一点例外：在Java中，你必须对每一个向前的斜杠（“\”）进行转义处理。图十不是Java的表示形式，所以我们要在每个“\”前面加上一个“\”以免出现编译错误。遗憾的是，转义处理过程很容易出现错误，所以应该小心谨慎。你可以首先输入未经转义处理的正则表达式，然后从左到右依次把每一个“\”替换成“\\”。如果要复检，你可以试着把它输出到屏幕上。

初始化字符串之后，实例化PatternCompiler对象，用PatternCompiler编译正则表达式创建一个Pattern对象：

现在，创建PatternMatcher对象，调用PatternMatcher接口的contain()方法检查匹配情况：

接下来，利用PatternMatcher接口返回的MatchResult对象，输出匹配的组。由于logEntry字符串包含匹配的内容，你可以看到类如下面的输出：

3.2 HTML处理实例一

下面一个任务是分析HTML页面内FONT标记的所有属性。HTML页面内典型的FONT标记如下所示：

程序将按照如下形式，输出每一个FONT标记的属性：

在这种情况下，我建议你使用两个正则表达式。第一个如图十一所示，它从字体标记提取出“"face="Arial, Serif" size="+2" color="red"”。

图十一：匹配FONT标记的所有属性

第二个正则表达式如图十二所示，它把各个属性分割成名字-值对。

图十二：匹配单个属性，并把它分割成名字-值对

分割结果为：

现在我们来看看完成这个任务的Java代码。首先创建两个正则表达式字符串，用Perl5Compiler把它们编译成Pattern对象。编译正则表达式的时候，指定Perl5Compiler.CASE_INSENSITIVE_MASK选项，使得匹配操作不区分大小写。

接下来，创建一个执行匹配操作的Perl5Matcher对象。

假设有一个String类型的变量html，它代表了HTML文件中的一行内容。如果html字符串包含FONT标记，匹配器将返回true。此时，你可以用匹配器对象返回的MatchResult对象获得第一个组，它包含了FONT的所有属性：

接下来创建一个PatternMatcherInput对象。这个对象允许你从最后一次匹配的位置开始继续进行匹配操作，因此，它很适合于提取FONT标记内属性的名字-值对。创建PatternMatcherInput对象，以参数形式传入待匹配的字符串。然后，用匹配器实例提取出每一个FONT的属性。这通过指定PatternMatcherInput对象（而不是字符串对象）为参数，反复地调用PatternMatcher对象的contains()方法完成。PatternMatcherInput对象之中的每一次迭代将把它内部的指针向前移动，下一次检测将从前一次匹配位置的后面开始。

本例的输出结果如下：

3.3 HTML处理实例二

下面我们来看看另一个处理HTML的例子。这一次，我们假定Web服务器从widgets.acme.com移到了newserver.acme.com。现在你要修改一些页面中的链接：

执行这个搜索的正则表达式如图十三所示：

图十三：匹配修改前的链接

如果能够匹配这个正则表达式，你可以用下面的内容替换图十三的链接：

注意#字符的后面加上了$1。Perl正则表达式语法用$1、$2等表示已经匹配且提取出来的组。图十三的表达式把所有作为一个组匹配和提取出来的内容附加到链接的后面。

现在，返回Java。就象前面我们所做的那样，你必须创建测试字符串，创建把正则表达式编译到Pattern对象所必需的对象，以及创建一个PatternMatcher对象：

接下来，用com.oroinc.text.regex包Util类的substitute()静态方法进行替换，输出结果字符串：

Util.substitute()方法的语法如下：

这个调用的前两个参数是以前创建的PatternMatcher和Pattern对象。第三个参数是一个Substiution对象，它决定了替换操作如何进行。本例使用的是Perl5Substitution对象，它能够进行Perl5风格的替换。第四个参数是想要进行替换操作的字符串，最后一个参数允许指定是否替换模式的所有匹配子串（Util.SUBSTITUTE_ALL），或只替换指定的次数。

【结束语】在这篇文章中，我为你介绍了正则表达式的强大功能。只要正确运用，正则表达式能够在字符串提取和文本修改中起到很大的作用。另外，我还介绍了如何在Java程序中通过Jakarta-ORO库利用正则表达式。至于最终采用老式的字符串处理方式（使用StringTokenizer，charAt，和substring），还是采用正则表达式，这就有待你自己决定了。

快乐着飞舞着 2005-08-16 10:23 发表评论

正则表达式和Java编程语言[转载 ]

快乐着飞舞着 — Tue, 16 Aug 2005 02:22:00 GMT

http://www.yesky.com/SoftChannel/72342371961929728/20030611/1706928.shtml

应用程序常常需要有文本处理功能，比如单词查找、电子邮件确认或XML文档集成。这通常会涉及到模式匹配。Perl、sed或awk等语言通过使用正则表达式来改善模式匹配，正则表达式是一串字符，它所定义的模式可用来查找匹配的文本。为了使用Java^TM编程语言进行模式匹配，需要使用带有许多charAt子字串的StringTokenizer 类，读取字母或符号以便处理文本。这常常导致复杂或凌乱的代码。

　　现在不一样了。

　　2平台标准版（J2SE^TM）1.4版包含一个名为java.util.regex的新软件包，使得使用正则表达式成为可能。目前的功能包括元字符的使用，它赋予正则表达式极大的灵活性

　　本文概括地介绍了正则表达式的使用，并详细解释如何利用 java.util.regex软件包来使用正则表达式，用以下常见情形作为例子：

简单的单词替换
电子邮件确认
从文件中删除控制字符
查找文件

　　为了编译这些例子中的代码和在应用程序中使用正则表达式，需要安装 J2SE 1.4版。

　　构造正则表达式

　　正则表达式是一种字符模式，它描述的是一组字符串。你可以使用 java.util.regex软件包，查找、显示或修改输入序列中出现的某个模式的一部分或全部。

　　正则表达式最简单的形式是一个精确的字符串，比如“Java”或 “programming”。正则表达式匹配还允许你检查一个字符串是否符合某个具体的句法形式，比如是不是一个电子邮件地址。

　　为了编写正则表达式，普通字符和特殊字符都要使用：

\$	^	.	*
+	?	['	']
\.

　　正则表达式中出现的任何其他字符都是普通字符，除非它前面有个 \。

　　特殊字符有着特别的用处。例如，.可匹配除了换行符之外的任意字符。与 s.n这样的正则表达式匹配的是任何三个字符的、以s 开始以n结束的字符串，包括sun和son 。

　　在正则表达式中有许多特殊字符，可以查找一行开头的单词，忽略大小写或大小写敏感的单词，还有特殊字符可以给出一个范围，比如a-e表示从a到e的任何字母。

　　使用这个新软件包的正则表达式用法与Perl类似，所以如果你熟悉Perl中正则表达式的使用，就可以在Java语言中使用同样的表达式语法。如果你不熟悉正则表达式，下面是一些入门的例子：

构造	匹配于
字符
x	字符 x
`\\`	反斜线字符
`\0`n	八进制值的字符`0`n (0 `<=` n `<=` 7)
`\0`nn	八进制值的字符 `0`nn (0 `<=` n `<=` 7)
`\0`mnn	八进制值的字符0mnn `0`mnn (0 `<=` m `<=` 3, 0 `<=` n `<=` 7)
`\x`hh	十六进制值的字符`0x`hh
`\u`hhhh	十六进制值的字符`0x`hhhh
`\t`	制表符(`'\u0009'`)
`\n`	换行符 (`'\u000A'`)
`\r`	回车符 (`'\u000D'`)
`\f`	换页符 (`'\u000C'`)
`\a`	响铃符 (`'\u0007'`)
`\e`	转义符 (`'\u001B'`)
`\c`x	T对应于x的控制字符 x

字符类
`[abc]`	`a`, `b`, or `c` (简单类)
`[^abc]`	除了`a`、`b`或`c`之外的任意字符（求反）
`[a-zA-Z]`	`a`到`z`或`A`到`Z` ，包含（范围)
`[a-z-[bc]]`	`a`到`z`，除了`b`和`c` ： `[ad-z]`（减去）
`[a-z-[m-p]]`	`a`到`z`，除了`m`到 `p`： `[a-lq-z]`
`[a-z-[^def]]`	`d`, `e`, 或 `f`
预定义的字符类
`.`	任意字符（也许能与行终止符匹配，也许不能）
`\d`	数字: `[0-9]`
`\D`	非数字: `[^0-9]`
`\s`	空格符: `[ \t\n\x0B\f\r]`
`\S`	非空格符: `[^\s]`
`\w`	单词字符: `[a-zA-Z_0-9]`
`\W`	非单词字符: `[^\w]`

快乐着飞舞着 2005-08-16 10:22 发表评论

java正则表达式; regular expression[转载]

快乐着飞舞着 — Tue, 16 Aug 2005 02:22:00 GMT

java正则表达式; regular expression

概要

文本处理经常涉及的根据一个pattern的匹配。尽管java的character和assorted 的String类提供了low-level的pattern-matching支持，这种支持一般带来了复杂的代码。为了帮助你书写简单的pattern-matching代码，java提供了regular expression。在介绍给你术语和java.util.regex包之后，Jeff Friesen explores 了许多那个包的Pattern类支持的正则表达式结构。然后他examines 了Pattern的方法和附加的java.util.regex 类。作为结束，他提供了一个正则表达式的实践应用。

为察看术语列表，提示与警告，新的homework，上个月homework的回答，这篇文章的相关材料，请访问study guide. (6,000 words; February 7, 2003)

By Jeff Friesen ，Translated By humx

文本处理经常的要求依据特定pattern匹配的代码。它能让文本检索，email header验证，从普通文本的自定义文本的创建（例如，用"Dear Mr. Smith" 替代 "Dear Customer"），等等成为可能。Java通过character和assorted string类支持pattern matching。由于low-level的支持一般带来了复杂的pattern-matching代码，java同时提供了regular expression来简代码。

Regular expressions经常让新手迷惑。然而, 这篇文章驱散了大部分混淆。在介绍了regular expression术语，java.util.regex 包中的类, 和一个regular expression constructs的示例程序之后, 我explore了许多Pattern类支持的regular expression constructs。我也examine了组成Pattern 和java.util.regex 包中其它类的方法。一个practical 的正则表达式的应用程序结束了我的讨论。

Note

Regular expressions的漫长历史开始于计算机科学理论领域自动控制原理和formal 语言理论。它的历史延续到Unix和其它的操作系统，在那里正则表达式被经常用作在Unix和Unix-like的工具中：像awk（一个由其创作者，Aho, Weinberger, and Kernighan，命名，能够进行文本分析处理的编程语言）, emacs (一个开发工具)，和grep (一个在一个或多个文件中匹配正则表达式，为了全局地正则表达式打印的工具。

什么是正则表达式?
A regular expression，也被known as regex or regexp，是一个描述了一个字符串集合的pattern(template)。这个pattern决定了什么样的字符串属于这个集合，它由文本字符和元字符（metacharacters，由有特殊的而不是字符含义的字符）组成。为了识别匹配的检索文本的过程—字符串满足一个正则表达式—称作模式匹配（pattern matching）。

Java''s java.util.regex 包通过Pattern，Matcher类和PatternSyntaxException异常支持pattern matching：

Pattern 对象，被known as patterns，是编译的正则表达式。
Matcher 对象，或者matchers，在，实现了java.lang.CharSequence接口并作为文本source的字符序列中定位解释matchers的引擎。
PatternSyntaxException 对象描述非法的regex patterns。
Listing 1 介绍这些类：

Listing 1. RegexDemo.java

// RegexDemo.java
import java.util.regex.*;

class RegexDemo {
public static void main (String [] args) {
if (args.length != 2)
System.err.println ("java RegexDemo regex text");
return;
}
Pattern p;
try {
p = Pattern.compile (args [0]);
}
catch (PatternSyntaxException e) {
System.err.println ("Regex syntax error: " + e.getMessage ());
System.err.println ("Error description: " + e.getDescription ());
System.err.println ("Error index: " + e.getIndex ());
System.err.println ("Erroneous pattern: " + e.getPattern ());
return;
}

String s = cvtLineTerminators (args [1]);
Matcher m = p.matcher (s);

System.out.println ("Regex = " + args [0]);
System.out.println ("Text = " + s);
System.out.println ();
while (m.find ()) {
System.out.println ("Found " + m.group ());
System.out.println (" starting at index " + m.start () +
" and ending at index " + m.end ());
System.out.println ();
}
}

// Convert \n and \r character sequences to their single character
// equivalents

static String cvtLineTerminators (String s) {
StringBuffer sb = new StringBuffer (80);

int oldindex = 0, newindex;
while ((newindex = s.indexOf ("\\n", oldindex)) != -1) {
sb.append (s.substring (oldindex, newindex));
oldindex = newindex + 2;
sb.append (''\n'');
}
sb.append (s.substring (oldindex));

s = sb.toString ();

sb = new StringBuffer (80);

oldindex = 0;
while ((newindex = s.indexOf ("\\r", oldindex)) != -1) {
sb.append (s.substring (oldindex, newindex));
oldindex = newindex + 2;
sb.append (''\r'');
}
sb.append (s.substring (oldindex));

return sb.toString ();
}
}

RegexDemo''s public static void main(String [] args) 方法validates 两个命令行参数：一个指出正则表达式，另外一个指出文本。在创建一个pattern之后，这个方法转换所有的文本参数，new-line and carriage-return line-terminator 字符序列为它们的实际meanings 。例如，一个new-line字符序列(由反斜杠后跟n表示)转换成一个new-line字符（用数字表示为10）。在输出了regex和被转换的命令行文本参数之后，main(String [] args) 方法从pattern创建了一个matcher，它随后查找了所有的matches 。对于每一个match，它所出现的字符和信息的位置被输出。

为了完成模式匹配，RegexDemo 调用了java.util.regex包中类的不同的方法。不要使你自己现在就理解这些方法；我们将在后边的文章探讨它们。更重要的是，编译 Listing 1: 你需要RegexDemo.class来探索Pattern''s regex 结构。

探索Pattern''s regex 构造

Pattern''s SDK 文档提供了一部分正则表达式结构的文档。除非你是一个avid正则表达式使用者，一个最初的那段文档的阅读会让你迷惑。什么是quantifiers，greedy之间的不同是什么, reluctant, 和 possessive quantifiers? 什么是 character classes， boundary matchers， back references, 和 embedded flag expressions? 为了回答这些和其它的问题，我们探索了许多Patter认可的regex constructs或 regex pattern 种类。我们从最简单的regex construct 开始：literal strings。

Caution

不要认为Pattern和Perl5的正则表达式结构是一样的。尽管他们有很多相同点，他们也有许多，它们支持的metacharacters结构的不同点。 (更多信息，察看在你的平台上的你的SDK Pattern类的文档。)

Literal strings

当你在字处理软件的检索对话框输入一个你指定一个literal string 的时候，你就指定了一个regex expression construct 。执行以下的RegexDemo 命令行来察看一下这个regex construct 的动作：

java RegexDemo apple applet

上边的这个命令行确定了apple 作为一个包含了字符a, p, p, l, and e（依次）的字符regex construct。这个命令行同时也确定了applet 作为pattern-matching的文本。执行命令行以后，看到以下输出：

Regex = apple
Text = applet

Found apple
starting at index 0 and ending at index 5

输出的regex 和text 命令行，预示着在applet中一个applet的成功的匹配，并表示了匹配的开始和结束的索引：分别为0和5。开始索引指出了一个pattern match出现的第一个文本的开始位置，结束索引指明了这个match后的第一个text的位置。换句话说，匹配的text的范围包含在开始索引和去掉结束索引之间（不包含结束索引）。

Metacharacters

尽管string regex constructs 是有用的，更强大的regex contsruct联合了文本字符和元字符。例如，在a.b，这个句点metacharacter (.) 代表在a个b之间出现的任何字符。为了察看元字符的动作，执行以下命令行：

java RegexDemo .ox "The quick brown fox jumps over the lazy ox."

以上命令指出.ox 作为regex ，和The quick brown fox jumps over the lazy ox.作为文本源text。RegexDemo 检索text来匹配以任意字符开始以ox结束的match，并产生如下输出：

Regex = .ox
Text = The quick brown fox jumps over the lazy ox.

Found fox
starting at index 16 and ending at index 19

Found ox
starting at index 39 and ending at index 42

这个输出展示了两个matches:fox和ox。. metacharacter 在第一个match中匹配f ，在第二个match中匹配空格。

假如我们用前述的metacharacter 替换.ox会怎么样呢？也就是，我们指定java RegexDemo . "The quick brown fox jumps over the lazy ox."会有什么样的输出，因为period metacharacter 匹配任何字符， RegexDemo 在命令行输出每一个匹配字符，包括结尾的period字符。

Tip

为了指定.或者任何的元字符作为在一个regex construct 作为literal character，引用—转换meta状态到literal status—用以下两种方法之一：

在元字符之前放置反斜杠。
将元字符放在\Q和\E之间（例如：\Q.\E）。
在每种情形下，不要忘记在string literal（例如：String regex = \\.;

）中出现时（像 \\. or \\Q.\\E）的双倍的反斜杠。不要在当它在命令行参数中出现的时候用双倍的反斜杠。

Character classes

有时我们限定产生的matches到一个特定的字符集和。例如，我们可以检索元音a, e, i, o, and u ，任何一个元音字符的出现都以为着一个match。A character类，通过在方括号之间的一个字符集和指定的regex construct ，帮我们完成这个任务。Pattern 支持以下的character classes：

简单字符: 支持被依次放置的字符串并仅匹配这些字符。例如：[abc] 匹配字符a, b, and c。以下的命令行提供了另外一个示例：
java RegexDemo [csw] cave

java RegexDemo [csw] cave [csw]中c匹配在cave中的c。没有其它的匹配存在。

否定: 以^ metacharacter 元字符开始且仅匹配没有在class中出现的字符。例如：[^abc]匹配所有除了a, b, 和c以外的字符，以下的命令行提供了另外一个示例：
java RegexDemo [^csw] cave

java RegexDemo [^csw] cave 匹配在cave中遇到的a, v, 和e。没有其它的匹配存在。

范围: 包含在元字符（-）左侧的字符开始，元字符（-）右侧字符结束的所有字符。仅匹配在范围内的字符。例如： [a-z] 匹配所有的小写字母。以下的命令行提供了另外一个示例：
java RegexDemo [a-c] clown

java RegexDemo [a-c] clown 匹配在clown中的c。没有其它的匹配存在。

Tip

通过将它们放置在一起来在一个range character class内联合多个范围。例如：[a-zA-Z] 匹配所有的大写和小写字母。

联合: 由多个嵌套的character classes组成，匹配属于联合结果的所有字符。例如：[a-d[m-p]] 匹配字符a到d和m到p。 characters a through d and m through p。以下的命令行提供了另外一个示例：
java RegexDemo [ab[c-e]] abcdef

java RegexDemo [ab[c-e]] abcdef 匹配它们在abcdef中的副本 a, b, c, d, and e。没有其它的匹配存在。

交集: 由所有嵌套的class的共同部分组成，且仅匹配字符的共同部分。例如：[a-z&&[d-f]] 匹配字符d, e, 和 f。以下的命令行提供了另外一个示例：
java RegexDemo [aeiouy&&[y]] party

java RegexDemo [aeiouy&&[y]] party 匹配在party中的y。没有其它的匹配存在。

差集: 由除了那些在否定嵌套character class中的字符外所有保留的字符组成。例如：[a-z&&[^m-p]] 匹配字符a到l和q到z。以下的命令行提供了另外一个示例：
java RegexDemo [a-f&&[^a-c]&&[^e]] abcdefg

java RegexDemo [a-f&&[^a-c]&&[^e]] abcdefg 匹配在abcdefg中的 d 和f。没有其它的匹配存在。

预定义的character classes

一些在regexes 中出现足够次数的character classes 提供了shortcuts。Pattern用预定义的character class提供了这样的shortcuts，如Table 1所示。使用预定义的character classes来简化你的regexes和最小化regex语法错误。

Table 1. 预定义的character classes

Predefined character class
Description

\d
A 数字。相当于[0-9]。

\D
A 非数字。相当于[^0-9]。

\s
A whitespace character。相当于[ \t\n\x0B\f\r]。

\S
A 非空格字符。相当于[^\s]。

\w
A 一个字符。相当于[a-zA-Z_0-9]。

\W
A 非字符，相当于[^\w]。

随后的命令行示例使用了\w预定义character class来identify 命令行中的所有word characters。

java RegexDemo \w "aZ.8 _"

上边的命令行产生了以下的输出，它展示了句点和space characters 不被考虑为word character：

Regex = \w
Text = aZ.8 _

Found a
starting at index 0 and ending at index 1

Found Z
starting at index 1 and ending at index 2

Found 8
starting at index 3 and ending at index 4

Found _
starting at index 5 and ending at index 6

Note

Pattern的SDK文档引用句点元字符作为匹配除了line terminator，一个或者两个标志一行结束的预定义的标志之外的任何字符，除非 dotall mode (随后讨论)有效。Pattern 识别以下line terminators：

The 回车符 (\r\)
The 回行符 (\n)
The 回车符紧跟回行符 (\r\n)
The 回行字符 (\u0085)
The 行分割字符 (\u2028)
The 段落分割字符 (\u2029)

捕获组

Pattern支持在pattern匹配的过程中，一个regex construct 调用capturing group 来保存为了以后recall 的match的字符；此结构是由圆括号包围的字符序列。在捕获的group中的所有字符在匹配的过程中被作为一个单独的单元。例如，(Java) capturing group 结合了字符 J, a, v, 和a为一个单独单元。Capturing group依据在text中Java的出现来匹配Java pattern。每一个match用下一个匹配的Java字符替代了前一个match保存的Java字符。

Capturing groups 在其它capturing groups内被嵌套。例如：在(Java( language))，( language) 在(Java)内嵌套。每一个嵌套或非嵌套的capturing group有它自己的数字，数字从1开始，Capturing 数字从左边至右。在这个例子中，(Java( language))是capturing group 1，( language)是capturing group 2。在(a)(b)，(a)是捕获组1，(b)是捕获组2。

每一个capturing group随后通过a back reference来recall保存的match。指定跟随在一个反斜杠后的数字来指示一个capturing group，back reference来 recalls 一个capturing group捕获的文本字符。一个back reference 的出现导致了一个matcher 使用the back reference的 capturing group number来recall捕获组保存的match ，然后使用匹配的字符进行进一步的匹配操作。随后的示例示范了为了检查语法错误进行的text 搜索的用法：

java RegexDemo "(Java( language)\2)" "The Java language language"

这个例子使用(Java( language)\2) regex为了检查语法错误，来检索字符串The Java language language，那里Java直接地在两个连续出现的language之前。Regex 指定了两个capturing groups： number 1 is (Java( language)\2)，它匹配Java language language，number 2 is ( language), 它匹配由language跟随的space characer。\2 back reference recalls number 2''s 保存的match，它允许matcher检索空格后跟随language的第二次出现，which 直接地跟随space character and language的第一次出现。随后的输出显示了RegexDemo''s matcher 找到了什么：

Regex = (Java( language)\2)
Text = The Java language language

Found Java language language
starting at index 4 and ending at index 26

量词

Quantifiers大概是理解起来最让人迷惑的regex 结构。一部分混淆来自于尽力的理解18个量词逻辑（六个基本逻辑被组织为三个主要逻辑）。其它的一个混淆来自于费尽的0长度匹配的理解。一旦你理解了这个概念和18 categories，大部分(假如不是全部)混淆将消失。

Note

简要地, 着一部分主要讨论18 个quantifier categories 和zero-length 匹配的概念。为了更详尽的讨论和更多示例，请学习The Java Tutoria 的"Quantifiers"部分。

一个quantifier 是一个隐式或显示的为一个pattern绑定一个数量值的正则表达式结构。这个数字值解决定了匹配一个pattern的次数。Pattern的六个基本的quantifiers匹配一个pattern一次或者根本不匹配，0次或者多次，一次或者多次，一个精确的数字次数，至少x次和至少x次但不超过y次。

六个基本的quantifier categories 在每一个三个主要的类别：greedy， reluctant和 possessive中复制。Greedy quantifiers 尝试找到最长的匹配。与之对照，reluctant quantifiers 尝试找到最短的匹配。Possessive quantifiers 也尝试找到最长的匹配。然而，他们和greedy quantifies在工作方式上不同。尽管greedy 和possessive quantifiers 迫使一个matcher 在进行第一次匹配之前读取整个的text，greedy quantifiers 常常导致为了找到一个match进行多次尝试，然而possessive quantifiers 让一个matcher 仅尝试一个match一次。

随后的示例描述了六种基本的quantifiers 在greedy category类别下，单个fundamental quantifier 在每一个 reluctant 和 possessive categories类别下的行为。这些示例也描述了0匹配的概念：

1. java RegexDemo a? abaa: 使用一个greedy quantifier 来在abaa中匹配a 一次或者根本不匹配。以下是输出结果：

Regex = a?
Text = abaa

Found a
starting at index 0 and ending at index 1

Found
starting at index 1 and ending at index 1

Found a
starting at index 2 and ending at index 3

Found a
starting at index 3 and ending at index 4

Found
starting at index 4 and ending at index 4

这个输出展示了五次匹配。尽管第一、三和四次匹配的出现展示了三次匹配中位置并不奇怪，第一、第五次的匹配大概有点奇怪。这个匹配好像指出a匹配b和文本的结束。然而，不是这种情况。a?并不查找b和文本结尾。相反，它查找a的出现或者缺失。当a? 查找a失败的时候，它以零长度的匹配返回那个事实(a缺失)，在零长度那里起始和结束位置的索引相同。Zero-length matches 发生在空文本, 最后一个文本字符之后，或者任何量个字符之间。

2. java RegexDemo a* abaa: 使用一个greedy quantifier在abaa 中匹配a零次或多次。以下是输出结果：

Regex = a*
Text = abaa

Found a
starting at index 0 and ending at index 1

Found
starting at index 1 and ending at index 1

Found aa
starting at index 2 and ending at index 4

Found
starting at index 4 and ending at index 4

输出展示了四次匹配。像使用 a?，a* 产生了zero-length 匹配。第三个匹配，a* 匹配了aa, 很有趣。不像 a?，a* 匹配一个或者多个连续的a。

3. java RegexDemo a+ abaa: 使用一个greedy quantifier在abaa 中匹配a一次或多次。以下是输出结果：

Regex = a+
Text = abaa

Found a
starting at index 0 and ending at index 1

Found aa
starting at index 2 and ending at index 4

输出展示了两个匹配。不像 a? 和 a*，a+ 没有匹配a的却失。因而，没有零长度匹配产生。像 a*，a+匹配了连续的a。

4. java RegexDemo a{2} aababbaaaab: 使用greedy quantifier 来匹配中的每一个 aababbaaaab中的 aa序列。以下是输出结果：

Regex = a{2}
Text = aababbaaaab

Found aa
starting at index 0 and ending at index 2

Found aa
starting at index 6 and ending at index 8

Found aa
starting at index 8 and ending at index 10

5. java RegexDemo a{2,} aababbaaaab: 使用了greedy quantifier 来匹配在ababbaaaab中两个或更多的匹配，以下是输出结果：

Regex = a{2,}
Text = aababbaaaab

Found aa
starting at index 0 and ending at index 2

Found aaaa
starting at index 6 and ending at index 10

6. java RegexDemo a{1,3} aababbaaaab: 使用greedy quantifier 来匹配在aababbaaaab中出现的a、aa或者aaa。以下是输出结果：

Regex = a{1,3}
Text = aababbaaaab

Found aa
starting at index 0 and ending at index 2

Found a
starting at index 3 and ending at index 4

Found aaa
starting at index 6 and ending at index 9

Found a
starting at index 9 and ending at index 10

7. java RegexDemo a+? abaa: 使用一个reluctant quantifier 在abaa中一次或多次匹配a。以下是输出结果：

Regex = a+?
Text = abaa

Found a
starting at index 0 and ending at index 1

Found a
starting at index 2 and ending at index 3

Found a
starting at index 3 and ending at index 4

不像在第三个例中的greedy变量，reluctant 示例产生了三个单独的匹配，因为reluctant quantifier尽力的查找最短的匹配。

8. java RegexDemo .*+end "This is the end": 使用了possessive quantifier 来匹配在this is the end中的以end结尾的任意字符0次或者多次。以下是输出结果：

Regex = .*+end
Text = This is the end

由于这个possessive quantifier consume了整个文本，没有留下任何东西来匹配end，它没有产生匹配。相比之下，在java RegexDemo .*end "This is the end" 的greedy quantifier，因为它每次backing off一个字符直到最右端的end匹配，产生了一个匹配。(这个quantifier与greedy的不同就在后者的匹配过程中一旦匹配的字符，在随后的匹配中就不再使用。因此.*这部分正则表达式就匹配了全部的字符串，就没有字符可以与end匹配了。)

Boundary matchers

我们有时想在一行的开始、在单词的边界、文本的结束等等匹配pattern。使用 boundary matcher，一个指定了匹配边界的正则表达式结构，完成这个任务。Table 2 表示了Pattern的边界匹配支持。

Table 2. Boundary matchers

Boundary Matcher
Description

^
一行的开始

$
一行的结束

\b
单词的边界

\B
非单词边界

\A
文本的开始

\G
前一个匹配的结束

\Z
The end of the text (but for the final line terminator, if any)

\z
文本结束

下边的命令行示例使用了^ 边界匹配元字符 ensure 由零个或者多个字符跟随的行开始。

java RegexDemo ^The\w* Therefore

^ 指出了前三个字符必须匹配pattern后的T、h和e字符。可跟随任意数量的字符。以上的命令行产生以下输出：

Regex = ^The\w*
Text = Therefore

Found Therefore
starting at index 0 and ending at index 9

把命令行改为java RegexDemo ^The\w* " Therefore"。发生了什么事?因为在therefore前的一个空格，没有匹配被发现。

Embedded flag expressions

Matcher假设了确定的却省值，例如大小写敏感的匹配。一个程序可以使用an embedded flag expression 来覆盖缺省值，也就是，使用一个正则表达式结构，圆括号元字符包围一个问号元字符后跟小写字母。Pattern认可以下的embedded flag expressions ：

(?i): enables 大小写不敏感的pattern 匹配。例如：java RegexDemo (?i)tree Treehouse 来匹配tree和Tree。大小写敏感是缺省值。
(?x): 允许空格和注释用#元字符开始出现在Pattern中。一个matcher 忽略全部它们。例如：java RegexDemo ".at(?x)#match hat, cat, and so on" matter 匹配.at和mat。缺省地，空格和注释式不被允许的；一个matcher 将它们考虑为对match有贡献的字符。
(?s): 使dotall 方式有效。在这种模式中，句点除了其它字符外还匹配text结束。例如：java RegexDemo (?s). \n ，. 匹配了 \n。Nondotall 方式是缺省的：不匹配行结尾。
(?m): 使多行方式有效。在多行模式下 ^ and $ 恰好分别的在一行的终结或末端之后或者之前。例如：java RegexDemo (?m)^.ake make\rlake\n\rtake 匹配 .ake 和 make、 lake与 take。非多行模式是缺省的： ^ and $ match仅在整个文本的开始和结束。
(?u): enables Unicode-aware case folding. This flag works with (?i) to perform case-insensitive matching in a manner consistent with the Unicode Standard. The default: case-insensitive matching that assumes only characters in the US-ASCII character set match。
(?d): enables Unix lines mode. In that mode, a matcher recognizes only the \n line terminator in the context of the ., ^, and $ metacharacters. Non-Unix lines mode is the default: a matcher recognizes all terminators in the context of the aforementioned metacharacters。
Embedded flag expressions 类似于 capturing groups因为两个regex constructs都用圆括号包围字符。不像capturing group，embedded flag expression 没有捕获匹配的字符。因而，一个embedded flag expression是noncapturing group的特例。也就是说，一个不捕获text字符的regex construct ；它指定了由元字符圆括号包围的字符序列。在Pattern''s SDK 文档中出现了一些noncapturing groups。

Tip

为了在正则表达式中指定多个embedded flag 表达式。或者吧它们并排的放在一起 (e.g., (?m)(?i)) 或者把它们的小写字母并排的放在一起 (e.g., (?mi))。

探索java.util.regex 类的方法

java.util.regex包的三个类提供了为帮我书写更健壮的正则表达式代码和创建强大的text处理工具许多的方法。我们从Pattern类开始探索这些方法。

Note

你也可以explore CharSequence 接口的当你创建一个新的字符序列类要实现的方法。仅实现 CharSequence 接口的类是java.nio.CharBuffer， String，和 StringBuffer。

Pattern 方法

除非代码将一个string编译为Pattern对象一个regex表达式式没有用处的。用以下编辑方法中的一个完成这个任务：

public static Pattern compile(String regex): 将regex内容编译为在一个新的Pattern对象内存储的树状结构的对象表示。返回那个对象引用。例如：Pattern p = Pattern.compile ("(?m)^\\.")；创建了一个，存储了一个编译的表示了匹配以句点开始的行的表示。
public static Pattern compile(String regex, int flags): 完成前一个方法的相同任务。然而，它同时考虑包含了flag常量（flags指定的）。Flag常量在Pattern中（except the canonical equivalence flag, CANON_EQ）被作为二选一的embedded flag expressions被声明。例如：Pattern p = Pattern.compile ("^\\.", Pattern.MULTILINE)；和上一个例子等价，Pattern.MULTILINE 常量和the (?m) embedded flag 表达式完成相同的任务。(参考SDK''s Pattern 文档学习其它的常量。) 假如不是这些在Pattern中被定义的常量在flag中出现，方法将抛出IllegalArgumentException 异常。
假如需要，通过调用以下方法可以得到一个Pattern对象的flag和最初的被编译为对象的正则表达式：

public int flags(): 返回当正则表达式编译时指定的Pattern的flag。例如：System.out.println (p.flags ())；输出p引用的的Pattern相关的flag。
public String pattern(): 返回最初的被编译进Pattern的正则表达式。例如：System.out.println (p.pattern ())；输出对应p引用Pattern的正则表达式。（Matcher 类包含了类似的返回Matcher相关的Pattern对象的Pattern pattern() 方法。）
在创建一个Pattern对象后，你一般的通过调用Pattern的公有方法matcher(CharSequence text)获得一个Matcher对象。这个方法需要一个简单的，实现了CharSequence接口的文本对象参数。获得的对象在pattern匹配的过程中扫描输入的文本对象。例如：Pattern p = Pattern.compile ("[^aeiouy]"); Matcher m = p.matcher ("This is a test."); 获得一个在text中匹配所有非元音字母的matcher。

当你想检查一个pattern是否完全的匹配一个文本序列的时候创建Pattern和Matcher对象是令人烦恼的。幸运的是，Pattern提供了一个方便的方法完成这个任务；public static boolean matches(String regex, CharSequence text)。当且仅当整个字符序列匹配regex的pattern的场合下静态方法返回布尔值true。例如：System.out.println (Pattern.matches ("[a-z[\\s]]*", "all lowercase letters and whitespace only"));返回布尔值true，指出仅空格字符和小写字符在all lowercase letters and whitespace only中出现。

书写代码将text分成它的组成部分(例如雇员记录文件到一个字段的set) 是许多开发者发现乏味的任务。Pattern 通过提供一对字符分割方法来减轻那种tedium。

public String [] split(CharSequence text, int limit): 分割在当前的Pattern对象的pattern匹配周围的text。这个方法返回一个数组，它的每一个条目指定了一个从下一个由pattern匹配(或者文本结束)分开的字符序列；且所有条目以它们在text中出现相同的顺序存储。书组条目的数量依赖于limit，它同时也控制了匹配发生次数。一个正数意味着，至多，limit-1 个匹配被考虑且数组的长度不大于限定的条目数。一个负值以为着所有匹配的可能都被考虑且数组可以任意长。一个0值以为着所有可能匹配的条目都被考虑，数组可以有任意的长度，且尾部的空字符串被丢弃。
public String [] split(CharSequence text): 用0作为限制调用前边方法，返回方法调用的结果。
假如你想一个拆分雇员记录，包含了姓名，年龄，街道和工资，为它的组成部分。以下的代码用split(CharSequence text)方法完成了这个任务：

Pattern p = Pattern.compile (",\\s");
String [] fields = p.split ("John Doe, 47, Hillsboro Road, 32000");
for (int i = 0; i < fields.length; i++)
System.out.println (fields [i]);

The code fragment above specifies a regex that matches a comma character immediately followed by a single-space character and produces the following output:

John Doe
47
Hillsboro Road
32000

Note

String合并了三个方便的方法调用它们等价的Pattern方法： public boolean matches(String regex), public String [] split(String regex), and public String [] split(String regex, int limit)。

Matcher 方法

Matcher对象支持不同类型的pattern匹配操作，例如扫描text查找下一个match；尝试根据一个pattern来匹配整个文本；根据一个pattern尝试匹配部分text。用以下的方法完成这些任务：

public boolean find(): 扫描text查找下一个match。此方法，或者在text的开始扫描，假如上一次的方法调用返回true且这个matcher没有被reset，在前一个match后的第一个字符开始扫描。假如一个match被找到的话返回布尔值true。Listing 1 展示了一个例子。
public boolean find(int start): 重新安排matcher扫描下一个match。扫描从start指定的index开始。假如一个match被找到的话返回布尔值true。例如：m.find (1); 从index1开始扫描。(索引0被忽略。)假如start包含了一个负数或者一个超出了matcfher的text长度的值，这个方法抛出IndexOutOfBoundsException异常。
public boolean matches(): 尝试根据pattern匹配整个text。在这个text匹配的情形下返回true。例如： Pattern p = Pattern.compile ("\\w*"); Matcher m = p.matcher ("abc!"); System.out.println (m.matches ()); 输出false因为整个abc! text 包含了非字母word characters。
public boolean lookingAt(): 尝试根据pattern匹配text。假如一个match被找到的话返回布尔值true。不像 matches()，整个text不需要被匹配。例如：Pattern p = Pattern.compile ("\\w*"); Matcher m = p.matcher ("abc!"); System.out.println (p.lookingAt ()); 输出true因为text abc!的开始部分仅包含word 字符。
不像Pattern对象，Matcher 包含了状态信息。有时，你在一个pattern 匹配后想reset一个matcher清除那些信息。下边的方法reset了一个matcher：

public Matcher reset(): 重置了一个matcher的状态，包括matcher的append position(被清除为0)。下一个pattern的匹配操作从matcher新文本的起始开始。返回当前的matcher对象引用。例如：m.reset (); 通过引用m重置了matcher。
public Matcher reset(CharSequence text): 重新设置一个matcher的状态且设置了matcher的文本内同。下一个pattern的匹配操作在matcher新的文本的起始位置开始。返回当前的matcher对象引用。例如：m.reset ("new text"); 重置m引用的对象并制定新的text作为matcher的新text。
一个matcher的append position 决定了matcher的text的追加到一个StringBuffer对象中的开始位置。以下的方法使用了append position：

public Matcher appendReplacement(StringBuffer sb, String replacement): 读取matcher的text并将它们追加到sb引用的StringBuffer对象。这个方法在前一个pattern match的最后一个字符之后停止读取。此method 然后添加replacement引用的中的characters 到StringBuffer 对象。(替换字符串可以包含上一个匹配捕获的文本的引用，通过dollar-sign characters ($) 和 capturing group 数) 最终，这个方法设置了matcher的append position为最后一个匹配字符的位置加上1。一个当前的matcher对象的引用返回。假如这个matcher对象还没有执行match或者上次的match尝试失败此方法将抛出一个IllegalStateException 异常。假如replacement指定了一个pattern中不存在的capturing group 一个IndexOutOfBoundsException异常将被抛出。
public StringBuffer appendTail(StringBuffer sb): 追加所有的text 到StringBuffer对象并返回对象引用。在最后一次调用appendReplacement(StringBuffer sb, String replacement) 方法之后，调用appendTail(StringBuffer sb) copy剩余的text到StringBuffer对象。
随后的例子调用appendReplacement(StringBuffer sb, String replacement) 和 appendTail(StringBuffer sb) 方法来替换所有在one cat, two cats, or three cats on a fence 中出现的cat为caterpillar。一个capturing group 和在replacement中的capturing group的引用允许在每一个cat匹配后插入erpillar：

Pattern p = Pattern.compile ("(cat)");
Matcher m = p.matcher ("one cat, two cats, or three cats on a fence");
StringBuffer sb = new StringBuffer ();

while (m.find ())
m.appendReplacement (sb, "$1erpillar");

m.appendTail (sb);
System.out.println (sb);

此示例产生如下输出：

one caterpillar, two caterpillars, or three caterpillars on a fence

其它的两个替换方法使用替换的文本替换第一个match和所有的match成为可能：

public String replaceFirst(String replacement): 重置matcher，创建一个新的String对象，拷贝所有匹配的文本字符（直到第一个match）到String，追加替换字符到String，拷贝剩余的字符到Strring，并返回对象引用。（替换字符串可以包含上一个匹配捕获的文本的引用，通过dollar-sign characters ($) 和 capturing group 数。）
public String replaceAll(String replacement): 操作和上一个方法类似。然而，replaceAll(String replacement) 用替换字符替换所有匹配。
正则表达式\s+ 探测在文本中出现的一次或多次出现的空格。随后的例子使用了这个regex 并调用了replaceAll(String replacement) 方法来从text删除duplicate whitespace ：

Pattern p = Pattern.compile ("\\s+");
Matcher m = p.matcher ("Remove the \t\t duplicate whitespace. ");
System.out.println (m.replaceAll (" "));

此示例产生如下输出：

Remove the duplicate whitespace.

Listing 1 包含了System.out.println ("Found " + m.group ());. 注意方法调用group()。此方法是capturing group-oriented 的Matcher方法：

public int groupCount(): 返回在matcher的pattern中capturing groups 的个数。这个计数没有包含特定的capturing group 数字 0，它捕获前一个match（不管一个pattern包含capturing groups与否。）
public String group(): 通过capturing group 数字 0记录返回上一个match的字符。此方法可以根据一个空的字符串返回一个空字符串。假如match还没有被尝试或者上次的match操作失败将抛出IllegalStateException异常。
public String group(int group): 像上一个方法，除了通过group指定的capturing group number返回以前的match字符外。假如没有group number 指定的capturing group在pattern中存在，此方法抛出一个IndexOutOfBoundsException 异常。
以下代码示范了the capturing group 方法：

Pattern p = Pattern.compile ("(.(.(.)))");
Matcher m = p.matcher ("abc");
m.find ();

System.out.println (m.groupCount ());
for (int i = 0; i <= m.groupCount (); i++)
System.out.println (i + ": " + m.group (i));

The example produces the following output:

3
0: abc
1: abc
2: bc
3: c

Capturing group 数字0 保存了previous match 且与has nothing to do with whether 一个capturing group在一个pattern中出现与否没有任何关系。也就是 is (.(.(.)))。其它的三个capturing groups捕获了previous match属于这个capturing groups的字符。例如，number 2, (.(.)), 捕获 bc; and number 3, (.), 捕获 c.

在我们离开讨论Matcher的方法之前，我们将examine四个match位置方法：

public int start(): 返回previous match的开始位置。假如match还没有被执行或者上次的match失败，此方法抛出一个IllegalStateException异常。
public int start(int group): 类似上一个方法，除了返回group指定的capturing group 的相关的previous match 的开始索引外，假如在pattern中没有指定的capturing group number 存在，start(int group) 抛出IndexOutOfBoundsException 异常。
public int end(): 返回上次match中匹配的字符的索引位置加上1。假如match还没有被尝试或者上次的match操作失败将抛出IllegalStateException异常。
public int end(int group): 类似上一个方法，除了返回group指定的capturing group 的相关的previous match 的end索引外。假如在pattern中没有指定的capturing group number 存在，end(int group) 抛出IndexOutOfBoundsException 异常。
下边的示例示范了两个match position 方法，为capturing group number 2报告起始/结束match 位置：

Pattern p = Pattern.compile ("(.(.(.)))");
Matcher m = p.matcher ("abcabcabc");

while (m.find ())
{
System.out.println ("Found " + m.group (2));
System.out.println (" starting at index " + m.start (2) +
" and ending at index " + m.end (2));
System.out.println ();
}

The example produces the following output:

Found bc
starting at index 1 and ending at index 3

Found bc
starting at index 4 and ending at index 6

Found bc
starting at index 7 and ending at index 9

输出show我们仅仅对与capturing group number 2相关的matcher感兴趣，也就是这些匹配的起始结束位置。

Note

String 引入了两个方便的和调用Matcher等价的方法：public String replaceFirst(String regex, String replacement) 和 public String replaceAll(String regex, String replacement)。

PatternSyntaxException methods

Pattern的方法当它们发现非法的正则表达式语法错误的时候抛出PatternSyntaxException 异常。一个异常处理器可以调用PatternSyntaxException 的方法来获得抛出的关于语法错误的PatternSyntaxException 对象的信息。

public String getDescription(): 返回语法错误描述。
public int getIndex(): 返回语法错误发生位置的近似索引或-1，假如index是未知的。
public String getMessage(): 建立一个多行的，包含了其它三个方法返回的信息的综合，以可视的方式指出在pattern中错误的位置字符串。
public String getPattern(): 返回不正确的正则表达式。
因为PatternSyntaxException 从java.lang.RuntimeException继承而来，代码不需要指定错误handler。This proves appropriate when regexes are known to have correct patterns。但当有潜在的pattern语法错误存在的时候，一个异常handler是必需的。因而，RegexDemo的源代码(参看 Listing 1) 包含了try { ... } catch (ParseSyntaxException e) { ... }，它们调用了PatternSyntaxException四个异常方法中的每一个来获得非法pattern的信息。

什么组成了非法的pattern?在embedded flag expression 中没有指定结束的元字符结束符号就是一个例。假如你执行java RegexDemo (?itree Treehouse。此命令的非法正则表达式(?tree pattern 导致 p = Pattern.compile (args [0]); 抛出PatternSyntaxException 异常。你将看到如下输出：

Regex syntax error: Unknown inline modifier near index 3
(?itree
^
Error description: Unknown inline modifier
Error index: 3
Erroneous pattern: (?itree

Note

public PatternSyntaxException(String desc, String regex, int index) 构造函数让你创建你自己的PatternSyntaxException对象， That constructor comes in handy should you ever create your own preprocessing compilation method that recognizes your own pattern syntax, translates that syntax to syntax recognized by Pattern''s compilation methods, and calls one of those compilation methods. If your method''s caller violates your custom pattern syntax, you can throw an appropriate PatternSyntaxException object from that method。

一个正则表达式应用实践

Regexes let you create powerful text-processing applications. One application you might find helpful extracts comments from a Java, C, or C++ source file, and records those comments in another file. Listing 2 presents that application''s source code:

Listing 2. ExtCmnt.java

// ExtCmnt.java

import java.io.*;
import java.util.regex.*;

class ExtCmnt
{
public static void main (String [] args)
{
if (args.length != 2)
{
System.err.println ("usage: java ExtCmnt infile outfile");
return;
}

Pattern p;
try
{
// The following pattern lets this extract multiline comments that
// appear on a single line (e.g., /* same line */) and single-line
// comments (e.g., // some line). Furthermore, the comment may
// appear anywhere on the line.

p = Pattern.compile (".*/\\*.*\\*/|.*//.*$");
}
catch (PatternSyntaxException e)
{
System.err.println ("Regex syntax error: " + e.getMessage ());
System.err.println ("Error description: " + e.getDescription ());
System.err.println ("Error index: " + e.getIndex ());
System.err.println ("Erroneous pattern: " + e.getPattern ());
return;
}

BufferedReader br = null;
BufferedWriter bw = null;

try
{
FileReader fr = new FileReader (args [0]);
br = new BufferedReader (fr);

FileWriter fw = new FileWriter (args [1]);
bw = new BufferedWriter (fw);

Matcher m = p.matcher ("");
String line;
while ((line = br.readLine ()) != null)
{
m.reset (line);
if (m.matches ()) /* entire line must match */
{
bw.write (line);
bw.newLine ();
}
}
}
catch (IOException e)
{
System.err.println (e.getMessage ());
return;
}
finally // Close file.
{
try
{
if (br != null)
br.close ();

if (bw != null)
bw.close ();
}
catch (IOException e)
{
}
}
}
}

在创建Pattern 和Matcher 对象之后，ExtCmnt 逐行的读取一个文本文件的内容。对于每一行，matcher尝试匹配pattern的行，鉴别是一个单行的注释或者多行的注释在一行中出现。假如一行匹配pattern，ExtCmnt 将此行写入另外一个文本文件中。例如，java ExtCmnt ExtCmnt.java out 读取ExtCmnt.java 文件的每一行，根据pattern来尝试着一行，将匹配的行输出到名叫out的文件。 (不要担心理解文件的读写逻辑。我将在将来的文章中explore这些代码。) 在ExtCmnt执行完成，out 文件包含了以下行：

// ExtCmnt.java
// The following pattern lets this extract multiline comments that
// appear on a single line (e.g., /* same line */) and single-line
// comments (e.g., // some line). Furthermore, the comment may
// appear anywhere on the line.
p = Pattern.compile (".*/\\*.*\\*/|.*//.*$");
if (m.matches ()) /* entire line must match */
finally // Close file.

这个输出显示ExtCmnt 并不完美：p = Pattern.compile (".*/\\*.*\\*/|.*//.*$"); 没有描绘一个注释。出现在out中的行因为ExtCmnt的matcher匹配了//字符。

关于pattern ".*/\\*.*\\*/|.*//.*$"由一些有趣的事，竖线元字符metacharacter (|)。依照SDK documentation，圆括号元字符在capturing group和竖线元字符是逻辑操作符号。vertical bar 描述了一个matcher，它使用操作符左侧的正则表达式结构来在matcher的文本中定为一个match。假如没有match存在，matcher使用操作符号右侧的正则表达式进行再次的匹配尝试。

温习

尽管正则表达式简化了在text处理程序中pattern匹配的代码，除非你理解它们，否则你不能有效的在你的程序中使用正则表达式。这篇文章通过介绍给你regex terminology，the java.util.regex 包和示范regex constructs的程序来让你对正则表达式有一个基本的理解。既然你对regexes有了一个基本的理解，建立在通过阅读additional articles (see Resources)和学习java.util.regex''s SDK 文档，那里你可以学习更多的regex constructs ，例如POSIX (Portable Operating System Interface for Unix) 字符类。

我鼓励你用这篇文章中或者其它以前文章中资料中问题email me。(请保持问题和这个栏目讨论的文章相关性。)你的问题和我的回答将出现在相关的学习guides中。)

After writing Java 101 articles for 28 consecutive months, I''m taking a two-month break. I''ll return in May and introduce a series on data structures and algorithms.
About the author

Jeff Friesen has been involved with computers for the past 23 years. He holds a degree in computer science and has worked with many computer languages. Jeff has also taught introductory Java programming at the college level. In addition to writing for JavaWorld, he has written his own Java book for beginners—Java 2 by Example, Second Edition (Que Publishing, 2001; ISBN: 0789725932)—and helped write Using Java 2 Platform, Special Edition (Que Publishing, 2001; ISBN: 0789724685). Jeff goes by the nickname Java Jeff (or JavaJeff). To see what he''s working on, check out his Website at http://www.javajeff.com.

Resources

Download this article''s source code and resource files:
http://www.javaworld.com/javaworld/jw-02-2003/java101/jw-0207-java101.zip
For a glossary specific to this article, homework, and more, see the Java 101 study guide that accompanies this article:
http://www.javaworld.com/javaworld/jw-02-2003/jw-0207-java101guide.html
"Magic with Merlin: Parse Sequences of Characters with the New regex Library," John Zukowski (IBM developerWorks, August 2002) explores java.util.regex''s support for pattern matching and presents a complete example that finds the longest word in a text file:
http://www-106.ibm.com/developerworks/java/library/j-mer0827/
"Matchmaking with Regular Expressions," Benedict Chng (JavaWorld, July 2001) explores regexes in the context of Apache''s Jakarta ORO library:
http://www.javaworld.com/javaworld/jw-07-2001/jw-0713-regex.html
"Regular Expressions and the Java Programming Language," Dana Nourie and Mike McCloskey (Sun Microsystems, August 2002) presents a brief overview of java.util.regex, including five illustrative regex-based applications:
http://developer.java.sun.com/developer/technicalArticles/releases/1.4regex/
In "The Java Platform" (onJava.com), an excerpt from Chapter 4 of O''Reilly''s Java in a Nutshell, 4th Edition, David Flanagan presents short examples of CharSequence and java.util.regex methods:
http://www.onjava.com/pub/a/onjava/excerpt/javanut4_ch04
The Java Tutorial''s "Regular Expressions" lesson teaches the basics of Sun''s java.util.regex package:
http://java.sun.com/docs/books/tutorial/extra/regex/index.html
Wikipedia defines some regex terminology, presents a brief history of regexes, and explores various regex syntaxes:
http://www.wikipedia.org/wiki/Regular_expression
Read Jeff''s previous Java 101 column: "Tools of the Trade, Part 3" (JavaWorld, January 2003):
http://www.javaworld.com/javaworld/jw-01-2003/jw-0103-java101.html?
Check out past Java 101 articles:
http://www.javaworld.com/javaworld/topicalindex/jw-ti-java101.html
Browse the Core Java section of JavaWorld''s Topical Index:
http://www.javaworld.com/channel_content/jw-core-index.shtml
Need some Java help? Visit our Java Beginner discussion:
http://forums.devworld.com/webx?50@@.ee6b804
Java experts answer your toughest Java questions in JavaWorld''s Java Q&A column:
http://www.javaworld.com/javaworld/javaqa/javaqa-index.html
For Tips ''N Tricks, see:
http://www.javaworld.com/javaworld/javatips/jw-javatips.index.html
Sign up for JavaWorld''s free weekly Core Java email newsletter:
http://www.javaworld.com/subscribe
You''ll find a wealth of IT-related articles from our sister publications at IDG.net

快乐着飞舞着 2005-08-16 10:22 发表评论

skin L&F

快乐着飞舞着 — Sun, 03 Jul 2005 10:49:00 GMT

http://dev.l2fprod.com/tutorial-firstaid.html

快乐着飞舞着 2005-07-03 18:49 发表评论

一个关于 CMP entity bean 的诡异问题

快乐着飞舞着 — Fri, 01 Jul 2005 10:38:00 GMT

create table results(sno number(8) references students on delete cascade,
cno number(5) references courses on delete cascade,
primary key(sno,cno));

建立一个CMP Entity Bean
在这个bean 中有如下的方法：

1  /**
2   *
3   *
4   * The  ejbCreate method.
5   *
6   *
7   *
8   * @ejb.create-method
9   *
10   * @generated
11   */
12  public resultPK ejbCreate(Integer sno,Integer cno) throws javax.ejb.CreateException {
13    // EJB 2.0 spec says return null for CMP ejbCreate methods.
14    // TODO: YOU MUST INITIALIZE THE FIELDS FOR THE BEAN HERE.
15    // setMyField("Something");
16    // begin-user-code
17    // this.setCno(cno);
18    // this.setSno(sno);
19    return new resultPK(sno,cno);
20    // end-user-code
21  }
22
23  /**
24   *
25   * The container invokes this method immediately after it calls ejbCreate.
26   *
27   *
28   * @generated
29   */
30  public void ejbPostCreate(Integer sno,Integer cno) throws javax.ejb.CreateException {
31    // begin-user-code
32      try{
33        Hashtable props = new Hashtable();
34
35        props.put(InitialContext.INITIAL_CONTEXT_FACTORY,
36                "weblogic.jndi.WLInitialContextFactory");
37        props.put(InitialContext.PROVIDER_URL, "t3://127.0.0.1:7001");
38
39        InitialContext initialContext = new InitialContext(props);
40        csc.studentLocalHome studentlocalhome=(studentLocalHome)initialContext.lookup(csc.studentLocalHome.JNDI_NAME);
41        this.setStudent(studentlocalhome.findByPrimaryKey(sno));
42        csc.courseLocalHome courselocalhome=(courseLocalHome)initialContext.lookup(csc.courseLocalHome.JNDI_NAME);
43        this.setCourse(courselocalhome.findByPrimaryKey(cno));
44
45    }catch(Exception e){
46        e.printStackTrace();
47    }System.out.println("ejb postCreate");
48    // end-user-code
49  }
50

1  /**
2   * @ejb.relation
3   * name = "resultTOstudent"
4   * role-name = "result_student"
5   * target-ejb = "student"
6   * target-multiple = "yes"
7   *
8   * @weblogic.column-map
9   * foreign-key-column = "sno"
10   * key-column = "sno"
11   * @ejb.interface-method
12   * view-type = "local"
13   */
14 public abstract studentLocal getStudent();
15 /**
16  * @ejb.relation
17  * name = "resultTOCourse"
18  * role-name = "result_course"
19  * target-ejb = "course"
20  * target-multiple = "yes"
21  *
22  * @weblogic.column-map
23  * foreign-key-column = "cno"
24  * key-column = "cno"
25  * @ejb.interface-method
26  * view-type = "local"
27  */
28 public abstract courseLocal getCourse();

在客户程序中调用时

csc.result myBean = getHome().create(new Integer(Integer.parseInt("02012001")),new Integer(18));

有如下的错误：

javax.ejb.CreateException: [EJB:010148]In EJB 'result', the primary key field 'cno' was not set during ejbCreate. All primary key fields must be initialized during ejbCreate.

如果把 ejbCreate改成

1  public resultPK ejbCreate(Integer sno,Integer cno) throws javax.ejb.CreateException {
2    // EJB 2.0 spec says return null for CMP ejbCreate methods.
3    // TODO: YOU MUST INITIALIZE THE FIELDS FOR THE BEAN HERE.
4    // setMyField("Something");
5    // begin-user-code
6      this.setCno(cno);
7      this.setSno(sno);
8    return new resultPK(sno,cno);
9    // end-user-code
10  }

有下面的错误：

The setXXX method for a cmr-field that is mapped to a primary key may not be called. The cmr-field is read-only.

特别的是在第二种情况下 create 方法虽然有错误但是数据仍然插入了数据库，第一种情况下程序自然终止。

快乐着飞舞着 2005-07-01 18:38 发表评论

IT博客-快乐着飞舞着-随笔分类-Java

Spring + hibernate 的错误

一个诡异问题终于得已解决

Hibernate 的 主键生成

Hibernate 的错误

"struts中文问题"，"struts国际化问题"??终极解决方案[转载]

应用HttpClient来对付各种顽固的WEB服务器(3) [转]

应用HttpClient来对付各种顽固的WEB服务器(2) [转]

应用HttpClient来对付各种顽固的WEB服务器(1) [转]

有用的国外开源项目网址 [转]

应用HttpClient来对付各种顽固的WEB服务器(4) [转]

jfree中字体的调整

使用JFreeChart创建图象

在eclipse+myeclipse+weblogic下EJB开发所要注意的问题 [转]

昨天做梦都在写代码

使用 JFreeChart来创建基于web的图表（1）

使用 JFreeChart来创建基于web的图表（2）

用Java Swing制作欢迎屏幕(2)

用Java Swing制作欢迎屏幕(1) [转]

使用 JFreeChart来创建基于web的图表（3）

JFreeChart实时曲线(代码) [zz]

Java读取文件中含有中文的解决办法

Java正则表达式详解[转载]

Java正则表达式详解

正则表达式和Java编程语言[转载 ]

java正则表达式; regular expression[转载]

skin L&F

一个关于 CMP entity bean 的诡异问题

Hibernate 的主键生成