zxjava

Spring iBatis Clob

zxjava — Sun, 20 Jul 2008 18:08:52 +0800

作者: zxjava 链接：http://zxjava.javaeye.com/blog/216714 发表时间: 2008年07月20日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

iBATIS作为一个易于易用的orm(sql mapping)工具，已经广泛应用在国内的大量的项目中，成熟的iBATIS2已经为社区服务了三年之久，在iBATIS2.3.0中已经废弃了其自带的DAO的框架，转而推荐Spring 提供的ibatis support dao框架，从而得到所有依赖注入，bean管理和template以及声明式事务带来的好处。

本文就在使用过程中Spring DAO + iBATIS + Oracle Clob(Blob)存取时的一些问题的经验总结。

一、开发、测试环境描述
SUN JDK1.4.2
eclipse3.2.1
tomcat 5.0.28
spring-2.0.5.jar
ibatis-2.3.0.677.jar
ojdbc14-10.2.0.3.jar(thin)
commons-dbcp链接池

二、布署环境描述
IBM WebSphere 6.0.2.17

三、数据库描述
Oracle 10.2.0.2.0
采用thin模式连接

四、使用iBATIS自带的clobTypeHanle

读取：将clob字段对应的domain属性配置为String，不需做任何配置
insert,update，时不时出现问题，后采用变态方法，将clob字段移到insert语句的最后，将clob字段移到update的最前位置，问题解决，采用的内联的parametermap

select mmt_seq.nextval as id from dualselectKey>

insert into mmt_news_main(
id,
title,
info_source,
mod_index,
craft_index,
p_index,
p_name,
lang_type,
title_short,
title_deck,
brief,
add_date,
content
)values(
#id#,
#title#,
#info_source#,
#mod_index#,
#craft_index#,
#p_index#,
#p_name#,
#lang_type#,
#title_short#,
#title_deck#,
#brief#,
sysdate,
#content,javaType=java.lang.String,jdbcType=CLOB#
)
]]>

update mmt_news_main set
content=#content,javaType=java.lang.String,jdbcType=CLOB#,
mod_index=#mod_index#,
craft_index=#craft_index#,
p_index=#p_index#,
p_name=#p_name#,
lang_type=#lang_type#,
title=#title#,
info_source=#info_source#,
title_short=#title_short#,
title_deck=#title_deck#,
brief=#brief#
where id=#id#
]]>

但没有测试过多个clob字段的情况，不存在4000字符的问题。
注意，在插入语句中clob字段的java类型为java.io.StringReader

五、使用spring自带的OracleLobHandler

看了一下spring的源码中的注释
位置：org.springframework.jdbc.support.lob.OracleLobHandler
/**
* LobHandler implementation for Oracle databases. Uses proprietary API to
* create oracle.sql.BLOB and oracle.sql.CLOB
* instances, as necessary when working with Oracle's JDBC driver.
* Note that this LobHandler requires Oracle JDBC driver 9i or higher!
*
*

While most databases are able to work with DefaultLobHandler, Oracle just
* accepts Blob/Clob instances created via its own proprietary BLOB/CLOB API,
* and additionally doesn't accept large streams for PreparedStatement's
* corresponding setter methods. Therefore, you need to use a strategy like
* this LobHandler implementation.
*
*

Needs to work on a native JDBC Connection, to be able to cast it to
* oracle.jdbc.OracleConnection. If you pass in Connections from
* a connection pool (the usual case in a J2EE environment), you need to set
* an appropriate NativeJdbcExtractor to allow for automatical retrieval of
* the underlying native JDBC Connection. LobHandler and NativeJdbcExtractor
* are separate concerns, therefore they are represented by separate strategy
* interfaces.
*
*

Coded via reflection to avoid dependencies on Oracle classes.
* Even reads in Oracle constants via reflection because of different Oracle
* drivers (classes12, ojdbc14) having different constant values! As this
* LobHandler initializes Oracle classes on instantiation, do not define this
* as eager-initializing singleton if you do not want to depend on the Oracle
* JAR being in the class path: use "lazy-init=true" to avoid this issue.
*
* @author Juergen Hoeller
* @since 04.12.2003
* @see #setNativeJdbcExtractor
* @see oracle.sql.BLOB
* @see oracle.sql.CLOB
*/

大体的意思是：oracle使用私有的API产生oracle.sql.BLOB和oracle.sql.CLOB实例，oracle只接受其自己API产生的实例，并且在PreparedStatement中不支持大的数据流。

此实现类需要一个原生的可以被转换成oracle.jdbc.OracleConnection的链接，所以在使用连接池的时候，就需要一个原生JDBC的转换器。

原来如此，马上配置，快速搞定，在测试，生产环境中都没有问题，sqlMap也不需要注意clob字段的位置，以下是配置：

1、sqlMapConfig

xml 代码
xml version="1.0" encoding="UTF-8"?>

PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN"
"http://ibatis.apache.org/dtd/sql-map-config-2.dtd">

useStatementNamespaces="false" statementCachingEnabled="true" classInfoCacheEnabled="true" />

callback="org.springframework.orm.ibatis.support.BlobByteArrayTypeHandler" />
callback="org.springframework.orm.ibatis.support.ClobStringTypeHandler" />

sqlMapConfig>

2、spring配置(部分)

xml 代码

bean>

lazy-init="true" />

property>
bean>

property>
bean>

在发布环境中，要将nativeJdbcExtractor 换成 org.springframework.jdbc.support.nativejdbc.WebSphereNativeJdbcExtractor
留意log4j日志，此时的clob字段的java类型为oracle.sql.Clob
Spring内置提供的NativeJdbcExtractor转换器有：
C3P0NativeJdbcExtractor
CommonsDbcpNativeJdbcExtractor
JBossNativeJdbcExtractor
NativeJdbcExtractor
NativeJdbcExtractorAdapter
SimpleNativeJdbcExtractor
WebLogicNativeJdbcExtractor
WebSphereNativeJdbcExtractor
XAPoolNativeJdbcExtractor
基本上够用了。
位于org\springframework\jdbc\support\nativejdbc下

六、最后也总结一下：
ibatis 2.0.9 + (最新的是iBATIS-2.3.0.667)
oracle 10g driver + (最新的是ojdbc14-10.2.0.3.jar)
使用spring 提供的dao框架，按如上配置，不同的链接池采用不同的NativeJdbcExtractor
不需要写显式的parameterMap(我测试了也没有成功)，简洁好用的inline-parameterMap应该是首选，配合abator等自动化工具，ibatis照样能达到快速开发。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

XFire

zxjava — Thu, 17 Jul 2008 22:33:43 +0800

作者: zxjava 链接：http://zxjava.javaeye.com/blog/215962 发表时间: 2008年07月17日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

为了实现Web Services的平台无关性和实现访问独立性，软件行业需要遵循一些作为标准的技术。其中一些包括:---XML:在Web Services环境中各层之间进行传递的默认数据格式。　---SOAP:封装和交换信息的默认协议。第一次被提出时，它是只取Simple Object Access Protocol(简单对象访问协议)的首字母。但是现在SOAP更多被认为是一个特定的名词，以它自己而命名，同样很多人认为这是用词不当:SOAP实际上不是用来访问对象的。另外，它也不再简单。---WSDL(Web Services Description Language，Web Services描述语言):描述Web Services的语言。尽管基于XML并且可以被人理解，WSDL主要是由机器处理，由客户端程序读取和理解。下面的高级层次图表，基于WWW协会发布的“Web Services Architecture”(Web Services架构)文档，显示了这些技术在实际的工作环境中是如何发挥作用:

　　这个流程图显示了Web Services中的核心技术是如何工作的。这里，Provider是提供服务的应用程序组件，Requester是使用服务的客户端程序。很多其他技术也会参与到交互中，但是这个图只显示了在Web Services环境中必需的核心技术组件。XFire是一个免费的开源SOAP框架，它不仅可以极大方便地实现这样一个环境，并且可以提供许多Web Services规范中高级特征，这些特征在多数的商业或者开源工具都没有提供。你要恰当的理解这些单词:great ease and simplicity(非常轻松和简单)。你将会看到使用XFire创建Web Services是多么的简单。　假如你的Web应用有一个Java类，并且你想把它的一个方法发布为Web Services，当使用XFire时，你不需要编写一行额外的Java代码。只需要编辑发布描述符，然后你就会得到一个Web Services。是的，它相当地简单。我们来看一个例子。一个简单的Java类我们的例子是一个银行业应用程序，服务器是运行在J2SE1.4.2_07下的Apache Tomcat5.5.7。假定你已经了解如何使用Java编写Web应用程序，并知道应该如何把它部署到Apache Tomcat服务器上。我们的Web应用程序非常简单;它只做一件事——将资金从一个账户转到另外一个账户上。一个普通的Java类BankingService包含了一个叫做transferFunds()的方法来为我们完成这项工作。它需要四个输入参数:1、 String fromAccount 2、 String toAccount 　3、 double amount 4、 String currency
package com.mybank.xfire.example;
import java.text.NumberFormat;
import java.text.DecimalFormat;
/** XFire WebServices sample implementation class.
*/
public class BankingService implements IBankingService {

//Default constructor.
public BankingService(){
}

/** Transfers fund from one account to another.
*/
public String transferFunds(
String fromAccount, String toAccount, double amount, String currency){

String statusMessage = "";

//Call business objects and other components to get the job done.
//Then create a status message and return.
try {
NumberFormat formatter = new DecimalFormat("###,###,###,###.00");
statusMessage = "COMPLETED: " + currency + " " + formatter.format(amount)+
" was successfully transferred from A/C# " + fromAccount + " to A/C# " + toAccount;
} catch (Exception e){
statusMessage = "BankingService.transferFunds(): EXCEPTION: " + e.toString();
}
return statusMessage;
}

}
　　在这里你看到了什么异常的东西了吗?或许没有，除了默认的构造函数，类型是public。这是必须的。否则，XFire不能够初始化这个类。　　因为使用接口的设计是一个好的实践，所以我们的Java类也实现了一个称为IBankingService的接口。代码十分简单:
package com.mybank.xfire.example;
public interface IBankingService {
public String transferFunds(
String fromAccount, String toAccount, double amount, String currency);

}
　　在实际实现中，这样一个方法可能包括各种类型的复杂调用、查询和处理操作。但是我们的示例代码已经最小化了，以至于我们可以集中精力在主要目标上:把这个方法发布为Web Services。
　　你可以看到BankingService是一个普通的Java类，没有任何代码告诉我们它将会在Web Services中使用。好的，这里我们不需要增加任何东西。我们所有的工作都在部署描述符里完成。
　　Web应用的部署描述符
　　在Java中，Web应用程序通常需要至少一个部署描述符(叫做web.xml)对其进行配置。XFire本身是一个基于servlet的应用程序。因此，我们需要增加必要的引用到描述符文件中。然后我们还必须配置将要创建的Web Services。我们使用一个称为services.xml的新文件来完成这件事。
　　web.xml
　　首先，修改web.xml。我们需要增加下面的XFire servlet相关的条目:

XFireServlet

XFire Servlet

org.codehaus.xfire.transport.http.XfireConfigurableServlet

XFireServlet

/servlet/XFireServlet/*

XFireServlet

/services/*

services.xml现在我们不得不说一下我们的Web Services的由什么组成的了。这由一个叫做services.xml的文件完成，它存放在META-INF/xfire目录下，而这整个目录放在WEB-INF/classes文件夹中，它在Web应用程序的标准类路径中。这里是services.xml中的基本配置条目:

Banking
mybank
com.mybank.xfire.example.IBankingService
com.mybank.xfire.example.BankingService

　　让我们看看这里都包含了什么内容。Web Services的定义包含在元素中，它还含有一些子元素。第一个子元素是，它可以是你提供任何的合法名字。这将会被客户端程序和其它需要定位你的服务的组件用到。例如，在服务准备好以后，你将在浏览器上使用这个名字来查看WSDL。下一个子元素是。任何合法的XML名字都是可以的。用来唯一标识你的服务的各个参数。
元素包含了Java类的名字，它指定了方法签名。在我们的例子中，它是接口IBankingService。如果Java类没有实现任何接口，你就需要把类的名字放在这里。在你的Java类或者接口中可能有几个方法。只需要一个入口把它们全部发布为Web Services。保存了实现方法的Java类名。这是一个可选元素。如果上一个元素包含了一个接口，那么相应的实现类必须在这里指定。
　　就是这样。我们的Web Services配置完成了。　XFire和其它类库现在是最后一步了，需要得到所有必需的类库。我们怎样得到它们呢?去XFire网站，下载xfire-distribution-1.0.zip，然后解压到一个本地文件夹。复制下面的jar文件和它的库文件夹到WEB-INF/lib中:• activation-1.0.2.jar • commons-codec-1.3.jar • commons-httpclient-3.0.jar • commons-logging-1.0.4.jar • jaxen-1.1-beta-8.jar• jdom-1.0.jar • log4j-1.2.x.jar • mail-1.3.3_01.jar • spring-1.2.x.jar • stax-api-1.0.jar • wsdl4j-1.5.2.jar • wstx-asl-2.9.jar • xbean-2.1.0.jar • xbean-spring-2.2.jar • xfire-all-1.0.jar 　• XmlSchema-1.0.jar 一切妥当。我们来部署和启动应用程序。为了部署示例应用，只需要复制websvc.war到Apache Tomcat的webapps文件夹中，再等待几秒钟。它将会自动启动。这个应用的全部源代码也包含在这个war文件中。我们的程序已经准备作为一个Web Service了。我们如何知道Web Service正在工作呢?　为了了解Web Service是否正在工作，我们需要测试。首先，我们测试来看WSDL是否可用。我们在浏览器中输入URL。哪个URL?因为我们的应用程序的war文件是websvc.war，并且在services.xml中给出的服务名是Banking，WSDL的URL应该是:http://localhost:8080/websvc/services/Banking?wsdl。请注意:URL的第一部分，例如，http://localhost:8080，可能会根据你的应用服务器不同而不同。无论怎样，当你输入URL后，将会看到一个XML文档，它的根元素是。这个文档叫做服务的WSDL。如果你看到了，这就是你的应用作为Web Service已经可用的第一个证明。　但是这个测试是不够的。可能会发生这种情况，可以看到WSDL，但是从客户端程序可能会访问不到服务。因此为了核实服务是否可以访问了，我们必须使用一个客户端进行服务的实际调用来进行一个真正的测试。开发一个客户端　你可以使用任何的SOAP工具创建客户端，例如，.Net或者Apache Axis，有很多种方法:使用从WSDL产生的stubs，使用动态代理，等等。在例子中，我们使用一个动态代理，以一个简单的Servlet形式，叫做WsClient.java。为了保持代码两最小，所有在屏幕显示的元素都放在了doGet()方法中。对Web Service的实际调用由callWebService()方法完成，它相当地简单。和下面的类似:
/* Call the Web service
*
*/
public String callWebService(
String fromAccount, String toAccount, double amount, String currency)
throws MalformedURLException, Exception {

//Create a metadata of the service
Service serviceModel = new ObjectServiceFactory().create(IBankingService.class);
log.debug("callSoapServiceLocal(): got service model." );

//Create a proxy for the deployed service
XFire xfire = XFireFactory.newInstance().getXFire();
XFireProxyFactory factory = new XFireProxyFactory(xfire);

String serviceUrl = "http://localhost:8080/websvc/services/Banking";

IBankingService client = null;
try {
client = (IBankingService) factory.create(serviceModel, serviceUrl);
} catch (MalformedURLException e) {
log.error("WsClient.callWebService(): EXCEPTION: " + e.toString());
}

//Invoke the service
String serviceResponse = "";
try {
serviceResponse = client.transferFunds(fromAccount, toAccount, amount, currency);
} catch (Exception e){
log.error("WsClient.callWebService(): EXCEPTION: " + e.toString());
serviceResponse = e.toString();
}
log.debug("WsClient.callWebService(): status=" + serviceResponse);
//Return the response
return serviceResponse;
}
　　这个代码是如何工作的呢?我来解释一下:首先，我们创建一个服务模型，它包含服务的说明——换句话说，就是服务的元数据。我们使用XFire的ObjectServiceFactory从IBankingService.class接口创建这个模型。接着，为XFire获得一个代理工厂对象，它包含了常规的代码，也相当地简单和易懂。这一步中没有任何特定应用的东西。从这个proxyFactory，使用服务模型和服务端点URL(用来获得WSDL)，我们可以得到一个服务的本地代理。就是它了。这个代理就是实际的客户端。现在，我们可以调用它的transferFunds()方法来得到我们需要的Web Service。一旦示例应用发布并启动，就可以尝试servlet URL:http://localhost:8080/websvc/ws　这个Servlet使用默认参数来调用Web Service和显示接收到的响应。页面的最后两行应该读取:Response Received
　　COMPLETED: CDN$ 500.00 was successfully transferred from A/C# 11111-01234 to A/C# 99999-05678现在你可以确定Web Service已经发布并且在运行中了。
　　为了尝试不同的输入值，你可以使用完整的URL，例如:http://localhost:8080/websvc/ws?from=11-2345&to=77-9876&amt=250.00&cur=EUR。基本的Web Services开发步骤清单这个清单总结了将一个Java方法发布为Web Service所必须的步骤:　1、检查Java类的方法和默认构造函数确保为public 　2、增加XFire servlet相关条目到web.xml中　3、创建services.xml，把它放到WEB-INF/classes/META-INF/xfire目录下 4、增加XFire和第三方包到你的Web应用的WEB-INF/lib文件夹中
　　这就是所有需要的步骤，是的，相当简单。
　　XFire的其他高级特性
　　XFire的使用可能比较简单，但是在特性和功能性上，它却占据着领导者的位置。下面是它的高级特性:
• 　　---本地数据绑定支持POJOs(plain-old Java objects)、XMLBeans、JAXB(Java Architecture for XML Binding)、Castor等等。数据绑定说明了Web Services的XML请求和映射到Java对象的XML响应。
• 　　---使用StAX(Streaming API for XML)处理XML文档。同DOM的基于树和SAX的事件驱动的处理方式相比，StAX使用了拉(pull)机制，它使处理更快速，内存效率更高。
• 　　---支持多种传输协议，如HTTP、JMS(Java Message Service)和JVM内部传输。
• 　　---嵌入式，这是XFire的核心功能之一。你可以把这个SOAP引擎嵌入到你的应用中，完全隐藏所有XFire特定引用，同样所有配置都是程序驱动。
• 　　---丰富的API，它使XFire可高度自定义，允许开发者在不同的阶段截获请求，并且对他们进行处理。
• 　　---兼容最新的标准例如SOAP1.1(没有加密远程工程调用，或者RPC)和1.2、WSDL1.1、the Web Services Interoperability Organization’s Basic Profile 1.0、Web Services Addressing和WS-Security。
　　最重要的是，XFire属于新一代Web Services引擎。不仅仅是营销用语，“新一代”有一些重要的意义。Apache Axis是第一代Java语言的Web Services引擎，已经成为了所有后来工具的参考标准。在过去的几年里，Axis以及这些其它的工具已经在很多生产环境中进行了实地测试。从中得出的一个关键的问题就是Web Services并不最适合RPC类型的通信。对于性能和效率，面向文档的消息形式是最好的方式。但是Apache Axis和很多其他的Web Services引擎都被设计成了面向RPC的(尽管它们支持文档形式)。现在，整个行业正在开发新一代的SOAP引擎，设计为面向文档的。Apache已经宣布结束旧版本的Axis引擎开发，现在专注于Axis2，现在它的预发布版本是0.95。XFire在今年的2月份发布了它的第一个产品版本(1.0)。它的下一个版本(1.1)仅仅在几个星期之后就进行了发布。

　　性能
　　Web Services需要消耗很多资源，但是性能方面它们不是那么引人注目。XFire打破了这种趋势。它消耗更少的内存(部分因为 StAX的使用)，但是表现却比多数可比较的SOAP引擎出色。你可以在资源中提供的链接中看到比较的结果。
　　此外，XFire还提供了各种方法来进一步优化性能。一个方法是使用JVM内置传输(in-JVM transport)。如果你知道Web Services和客户端运行在同一个JVM上，你可以选择使用本地传输，它可以大幅提升性能。在示例中的客户端代码，看以下指定服务端点URL的这行:
　　String serviceUrl = "http://localhost:8080/websvc/services/Banking";
　　替换为
　　String serviceUrl = "xfire.local://Banking";
　　你会看到性能上的明显提高，因为它绕过了整个网络层。
　　局限性
　　XFire有些重要的局限性你应该清楚:
• 　　---开发Web Services的好的实践是从WSDL开始。大部分的SOAP引擎提供了从WSDL生成服务stub的工具。XFire也提供了这样一个工具。但是它是基于注释(annotations-based)的，因此需要J2SE5.0。对于仍坚持使用J2SE1.4.x的人来说，它不是一个令人拍手叫好的工具，因为我们有很多其他方式来编写客户端，一个就是文章中演示的方式。
• 　　---附件支持，它将会包含在未来发行的版本中。
• 　　---易于学习的用户向导。XFire团队在这个方面还有很多工作需要做。
　　结论
　　Java当前的趋势是简化技术的使用。因此，我们正看到一波基于POJO的开发成就。同时，面向服务架构(SOA，Services-oriented architecture)和Web Services已经变成了当前行业的热点话题。XFire正是在这种情况下产生的。它能够使POJO发布为最少的Web Services，而只需要付出最小化的努力。从而，它使希望使用这项技术的初级开发者的学习曲线变得平缓。同时，由于它兼容最新标准和提供了丰富的API，XFire为高级用户提供了更多的大好机会。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

Spring mvc 初体验

zxjava — Sat, 28 Jun 2008 18:33:56 +0800

作者: zxjava 链接：http://zxjava.javaeye.com/blog/208986 发表时间: 2008年06月28日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

这篇文章将教你快速地上手使用 Spring 框架. 如果你手上有一本《Spring in Action》, 那么你最好从第三部分"Spring 在 Web 层的应用--建立 Web 层"开始看, 否则那将是一场恶梦!

首先, 我需要在你心里建立起 Spring MVC 的基本概念. 基于 Spring 的 Web 应用程序接收到 http://localhost:8080/hello.do(事实上请求路径是 /hello.do) 的请求后, Spring 将这个请求交给一个名为 helloController 的程序进行处理, helloController 再调用一个名为 hello.jsp 的 jsp 文件生成 HTML 代码发给用户的浏览器显示. 上面的名称(/hello.do, helloController, hello.jsp) 都是变量, 你可以更改.

在 Spring MVC 中, jsp 文件中尽量不要有 Java 代码, 只有 HTML 代码和"迭代(forEach)"与"判断(if)"两个jstl标签. jsp 文件只作为渲染(或称为视图 View)模板使用.

好了, 我们开始吧. 首先我们需要一个放在 WEB-INF 目录下的 web.xml 文件:

web.xml:
1 2 3 7 8 9 contextConfigLocation10 11 /WEB-INF/database.xml12 /WEB-INF/applicationContext.xml13 14 15 16 17 org.springframework.web.context.ContextLoaderListener18 19 20 21 encodingFilter22 org.springframework.web.filter.CharacterEncodingFilter23 24 encoding25 UTF-826 27 28 29 30 encodingFilter31 *.do32 33 34 35 ideawu36 org.springframework.web.servlet.DispatcherServlet37 138 39 40 41 ideawu42 *.do43 44 45 46 index.jsp47 index.html48 49 50 51 52 http://java.sun.com/jsp/jstl/core53 /WEB-INF/tld/c.tld54 55 56 http://java.sun.com/jsp/jstl/fmt57 /WEB-INF/tld/fmt.tld58 59 60 61 它配置了以下功能:

配置 DispatcherServlet (servlet 标签), 它是一个 Java Servlet 程序. 我们将它命名为 ideawu. 然后我们再配置 Servlet 映射(servlet-mapping 标签), 也就是你希望哪些请求被DispatcherServlet处理. 这里, 我们设置后缀名为 do(*.do) 的所有URL请求都被名为 ideawu 的 DispatcherServlet 的程序处理. 选择 .do 只是一个习惯,但是你不要选择 .html! 虽然《Spring in Action》选择了 .html, 但是那是一种非常糟糕的作法, 特别是你整合 Apache 和 Tomcat 的时候.
配置 CharacterEncodingFilter (filter 标签), 否则你会发现中文乱码. 因为我的 jsp 和 html 文件都是 UTF-8 编码的, 所以我在 param-value 标签中设置了 UTF-8. 估计你使用的是 GB2312 或者 GBK, 立即转到 UTF-8 上来吧.
分解配置文件. context-param 标签指明我们的配置文件还有 /WEB-INF/database.xml 和 /WEB-INF/applicationContext.xml. ContextLoaderListener(listener 标签) 由此得知配置文件是哪些, 它会将它们载入.
因为我们将 DispatcherServlet 命名为 ideawu, 所以我们在 WEB-INF 目录下建立一个名为 ideawu-servlet.xml 的文件:

ideawu-servlet.xml:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 helloController15 16 17 18 19 20 23 24 25 它配置了以下功能:

配置 InternalResourceViewResolver, 它是 jsp 渲染模板的处理器. 如果你告诉 InternalResourceViewResolver 处理一个名为 hello 的模板时, 它会渲染 /WEB-INF/jsp/hello.jsp 文件. 把 jsp 文件放到 /WEB-INF/jsp/ 目录下是被鼓励的, 这样可以防止用户不经过 Controller 直接访问 jsp 文件从而出错(有些顽皮的人很喜欢这样做).
配置 SimpleUrlHandlerMapping, 在上面的配置文件中, /hello.do 的请求将被 helloController 处理. "/hello.do"和"helloController" 是变量, 你可以更改. 但是你注意到了吗, hello.do 以 .do 作为后缀名. 如果这里(本文的条件下)你不使用.do 作为后缀名, 就没有程序来处理这个请求了. 因为 DispatcherServlet 将收到的请求转交给 SimpleUrlHandlerMapping, DispatcherServlet 收不到的请求, SimpleUrlHandlerMapping 当然也收不到了. 你可以在 props 标签内配置多个 prop 标签.
我们将在后面编写 com.ideawu.HelloController 类.
上面, 我们在 web.xml 文件中告诉 ContextLoaderListener, 我们还有另外两个配置文件 /WEB-INF/database.xml 和 /WEB-INF/applicationContext.xml.

applicationContext.xml:
1 2 3 4 5 6 7 8 9 /WEB-INF/jdbc.properties10 11 12 13 14 它配置了以下功能:

读取 /WEB-INF/jdbc.properties 文件. 你可以在 list 标签中配置多个 value 标签.
database.xml:
1 2 3 4 5 6 14 15 20 21 26 27 它配置了以下功能(不过,已经注释掉了):

配置数据库连接. 类似${jbbc.url}是一种访问变量的方法. 我们可以从 /WEB-INF/jdbc.properties 中找到这个变量的值. 如果你的数据库已经配置好, 就将第一个注释去掉.
jdbc.properties:
1 jdbc.driverClassName=com.mysql.jdbc.Driver2 jdbc.url=jdbc:mysql://localhost/test?useUnicode=true&characterEncoding=UTF-83 jdbc.username=test4 jdbc.password=12345 现在, 我们来编写 Java 代码吧.
1 /*********************************************************** 2 * Date: 2006-8-26 3 * File: HelloController.java 4 * Author: ideawu 5 ***********************************************************/ 6 7 package com.ideawu; 8 9 import org.springframework.web.servlet.mvc.Controller;10 import org.springframework.web.servlet.ModelAndView;11 12 import javax.servlet.http.HttpServletRequest;13 import javax.servlet.http.HttpServletResponse;14 15 /**16 * @author ideawu17 *18 */19 public class HelloController implements Controller {20 /* 21 private HelloManager helloManager;22 23 public void setHelloManager(HelloManager helloManager) {24 this.helloManager = helloManager;25 }26 */27 28 public ModelAndView handleRequest(HttpServletRequest request,29 HttpServletResponse response)throws Exception{30 31 request.setAttribute("hello_1", "你好啊, Spring!");32 request.setAttribute("hello_2", "Hello World!");33 34 return new ModelAndView("hello");35 }36 37 }return new ModelAndView("hello"); 告诉 InternalResourceViewResolver jsp 模板的名字叫作 hello. request.setAttribute() 设置的对象我们可以在 jsp 文件中使用.

hello.jsp:
1 <%@ page contentType="text/html; charset=UTF-8" %> 2 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 3 4 5 6 7 Hello World! 8 9 10 11

${hello_1}

12 13

${hello_2}

14 15 16
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

synchronized的作用

zxjava — Thu, 05 Jun 2008 10:27:47 +0800

作者: zxjava 链接：http://zxjava.javaeye.com/blog/200403 发表时间: 2008年06月05日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

一、同步方法
public synchronized void methodAAA(){

//….

}
锁定的是调用这个同步方法的对象

测试：
a、不使用这个关键字修饰方法，两个线程调用同一个对象的这个方法。
目标类：

1public class TestThread {
2 public void execute(){ //synchronized,未修饰
3 for(int i=0;i<100;i++){
4 System.out.println(i);
5 }
6 }
7}

线程类：

1public class ThreadA implements Runnable{
2 TestThread test=null;
3 public ThreadA(TestThread pTest){ //对象有外部引入，这样保证是同一个对象
4 test=pTest;
5 }
6 public void run() {
7 test.execute();
8 }
9}
调用：
1TestThread test=new TestThread();
2Runnable runabble=new ThreadA(test);
3Thread a=new Thread(runabble,"A");
4a.start();
5Thread b=new Thread(runabble,"B");
6b.start();

结果：
输出的数字交错在一起。说明不是同步的，两个方法在不同的线程中是异步调用的。

b、修改目标类，增加synchronized修饰

1public class TestThread {
2 public synchronized void execute(){ //synchronized修饰
3 for(int i=0;i<100;i++){
4 System.out.println(i);
5 }
6 }
7}

结果：
输出的数字是有序的，首先输出A的数字，然后是B，说明是同步的，虽然是不同的线程，但两个方法是同步调用的。
注意：上面虽然是两个不同的线程，但是是同一个实例对象。下面使用不同的实例对象进行测试。

c、每个线程都有独立的TestThread对象。
目标类：

1public class TestThread {
2 public synchronized void execute(){ //synchronized修饰
3 for(int i=0;i<100;i++){
4 System.out.println(i);
5 }
6 }
7}
线程类：
1public class ThreadA implements Runnable{
2 public void run() {
3 TestThread test=new TestThread();
4 test.execute();
5 }
6}
7
调用：
1Runnable runabble=new ThreadA();
2Thread a=new Thread(runabble,"A");
3a.start();
4Thread b=new Thread(runabble,"B");
5b.start();

结果：
输出的数字交错在一起。说明虽然增加了synchronized 关键字来修饰方法，但是不同的线程调用各自的对象实例，两个方法仍然是异步的。

引申：
对于这种多个实例，要想实现同步即输出的数字是有序并且按线程先后顺序输出，我们可以增加一个静态变量，对它进行加锁(后面将说明锁定的对象)。

修改目标类：

1public class TestThread {
2 private static Object lock=new Object(); //必须是静态的。
3 public void execute(){
4 synchronized(lock){
5 for(int i=0;i<100;i++){
6 System.out.println(i);
7 }
8 }
9 }
10}
二、同步代码块

1public void method(SomeObject so){
2 synchronized(so)
3 //…..
4 }
5}
锁定一个对象，其实锁定的是该对象的引用（object reference）
谁拿到这个锁谁就可以运行它所控制的那段代码。当有一个明确的对象作为锁时，就可以按上面的代码写程序，但当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的instance变量（它必须是一个对象）来充当锁（上面的解决方法就是增加了一个状态锁）。

a、锁定一个对象，它不是静态的
private byte[] lock = new byte[0]; // 特殊的instance变量
目标类：

1public class TestThread {
2 private Object lock=new Object();
3 public void execute(){
4 synchronized(lock){ //增加了个锁，锁定了对象lock，在同一个类实例中，是线程安全的，但不同的实例还是不安全的。
5
6因为不同的实例有不同对象锁lock
7 for(int i=0;i<100;i++){
8 System.out.println(i);
9 }
10 }
11 }
12}

其实上面锁定一个方法，等同于下面的：

1public void execute(){
2 synchronized(this){ //同步的是当然对象
3 for(int i=0;i<100;i++){
4 System.out.println(i);
5 }
6 }
7}
b、锁定一个对象或方法，它是静态的
这样锁定，它锁定的是对象所属的类
public synchronized static void execute(){
//...
}
等同于

1public class TestThread {
2 public static void execute(){
3 synchronized(TestThread.class){
4 //
5 }
6 }
7}
测试：

目标类：

1public class TestThread {
2 private static Object lock=new Object();
3 public synchronized static void execute(){ //同步静态方法
4 for(int i=0;i<100;i++){
5 System.out.println(i);
6 }
7 }
8 public static void execute1(){
9 for(int i=0;i<100;i++){
10 System.out.println(i);
11 }
12 }
13 public void test(){
14 execute(); //输出是有序的，说明是同步的
15 //execute1(); //输出是无须的，说明是异步的
16 }
17}
线程类：调用不同的方法，于是建立了两个线程类

1public class ThreadA implements Runnable{
2 public void run() {
3 TestThread.execute();//调用同步静态方法
4 }
5}
6public class ThreadB implements Runnable{
7 public void run() {
8 TestThread test=new TestThread();
9 test.test();//调用非同步非静态方法
10 }
11}
调用：

1Runnable runabbleA=new ThreadA();
2Thread a=new Thread(runabbleA,"A");
3a.start();
4Runnable runabbleB=new ThreadB();
5Thread b=new Thread(runabbleB,"B");
6b.start();
注意:
1、用synchronized 来锁定一个对象的时候，如果这个对象在锁定代码段中被修改了，则这个锁也就消失了。看下面的实例：

目标类：

1public class TestThread {
2 private static final class TestThreadHolder {
3 private static TestThread theSingleton = new TestThread();
4 public static TestThread getSingleton() {
5 return theSingleton;
6 }
7 private TestThreadHolder() {
8 }
9 }
10
11 private Vector ve =null;
12 private Object lock=new Object();
13 private TestThread(){
14 ve=new Vector();
15 initialize();
16 }
17 public static TestThread getInstance(){
18 return TestThreadHolder.getSingleton();
19 }
20 private void initialize(){
21 for(int i=0;i<100;i++){
22 ve.add(String.valueOf(i));
23 }
24 }
25 public void reload(){
26 synchronized(lock){
27 ve=null;
28 ve=new Vector();
29 //lock="abc";
30 for(int i=0;i<100;i++){
31 ve.add(String.valueOf(i));
32 }
33 }
34 System.out.println("reload end");
35 }
36
37 public boolean checkValid(String str){
38 synchronized(lock){
39 System.out.println(ve.size());
40 return ve.contains(str);
41 }
42 }
43}
说明：在reload和checkValid方法中都增加了synchronized关键字，对lock对象进行加锁。在不同线程中对同一个对象实例分别调用reload和checkValid方法。
在reload方法中，不修改lock对象即注释lock="abc"; ，结果在控制台输出reload end后才输出100。说明是同步调用的。
如果在reload方法中修改lock对象即去掉注释，结果首先输出了一个数字(当前ve的大小)，然后输出reload end。说明是异步调用的。

2、单例模式中对多线程的考虑

1public class TestThread {
2 private static final class TestThreadHolder {
3 private static TestThread theSingleton = new TestThread();
4 public static TestThread getSingleton() {
5 return theSingleton;
6 }
7 private TestThreadHolder() {
8 }
9 }
10 private Vector ve =null;
11 private Object lock=new Object();
12 private TestThread(){
13 ve=new Vector();
14 initialize();
15 }
16 public static TestThread getInstance(){
17 return TestThreadHolder.getSingleton();
18 }
19 '''
20}
说明：增加了一个内部类，在内部类中申明一个静态的对象，实例化该单例类，初始化的数据都在单例类的构造函数中进行。这样保证了多个实例同时访问的时候，初始化的数据都已经成功初始化了。

总结：
A. 无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁,所以首先应知道需要加锁的对象
B．每个对象只有一个锁（lock）与之相关联。
C．实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

ibatis使用

zxjava — Wed, 28 May 2008 11:04:41 +0800

作者: zxjava 链接：http://zxjava.javaeye.com/blog/197780 发表时间: 2008年05月28日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

使用ibatis的十个理由,知道怎样操作10种以上的数据库
9 、可配置的caching(包括从属)
8、支持DataSource、local transaction managemen和global transaction
7、简单的XML配置文档
6、支持Map, Collection, List和简单类型包装(如Integer, String)
5、支持JavaBeans类(get/set 方法)
4、支持复杂的对象映射(如populating lists, complex object models)
3、对象模型从不完美(不需要修改)
2、数据模型从不完美(不需要修改)
1、你已经知道SQL，为什么还要学习其他东西

配至文件说明：DB.properties:

SimpleDriver=oracle.jdbc.OracleDriver
SimpleUrl=jdbc:oracle:thin:@10.0.0.5:1521:champion
SimpleUsername=root
SimplePassword=aa

sql-map-config-storedb.xml:

PUBLIC "-//iBATIS.com//DTD SQL Map Config 1.0//EN"
"http://www.ibatis.com/dtd/sql-map-config.dtd">

maxExecute="0"
maxExecutePerConnection="0"
maxTransactions="0"
cacheModelsEnabled="true"
statementCacheSize="175"
useBeansMetaClasses="false"
useGlobalTransactions="false" />

factory-class="com.ibatis.db.sqlmap.datasource.DbcpDataSourceFactory"
default="true" >

这里真正实现了数据库连接，我们使用的是dbcp的连接池。JDBC的配置大家都很熟了。${SimpleDriver}就是指的前面DB.properties中的SimpleDriver的内容。

Category.xml:

PUBLIC "-//iBATIS.com//DTD SQL Map 1.0//EN"
"http://www.ibatis.com/dtd/sql-map.dtd">

select CATID, NAME, DESCN from CATEGORY where CATID = #categoryId#

select CATID, NAME, DESCN from CATEGORY

CATID = #categoryId#

NAME = #name#

DESCN = #description#

select count(1) as value from CATEGORY

update CATEGORY

NAME = #name#

DESCN = #description#

where
CATID =#categoryId#

delete from CATEGORY
where CATID =#categoryId#

insert into CATEGORY (
CATID,NAME,DESCN)
values (
?,?,?
)

上述文件就是真正的SQL所存在的地方。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

JFreeChart教程

zxjava — Mon, 26 May 2008 15:35:49 +0800

作者: zxjava 链接：http://zxjava.javaeye.com/blog/197096 发表时间: 2008年05月26日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

一、JFreeChart获取。
JFreeChart是JFreeChart公司在开源网站SourceForge.net上的一个项目，该公司的主要产品有如下：
1、JFreeReport：报表解决工具
2、JFreeChart：Java图形解决方案（Application/Applet/Servlet/Jsp）
3、JCommon：JFreeReport和JFreeChart的公共类库
4、JFreeDesigner：JFreeReport的报表设计工具

我们可以从jfree官方网站上获取最新版本（最新的版本是1.0.5）和相关资料（但是jfree的Developer Guides是需要花美金才能获取），
获取地址：http://www.jfree.org/jfreechart/index.html（同时可以获得简明介绍）
我们以当前版本：jfreechart-1.0.0-rc3.tar.gz为例子进行说明

二、JFreeChart配置安装
1、解压jfreechart_0.9.21.zip到指定位置，其中source是jfreechart的源码，jfreechart-0.9.21-demo.jar
是例子程序（该部分留给大家自己去研究）
2、为了配置成功，我们需要关注的文件有如下三个：jfreechart-0.9.21.jar、lib\jcommon-0.9.6.jar、
lib\gnujaxp.jar
3、如果是Application开发，把上述三个文件拷贝到%JAVA_HOME%\LIB中，同时在环境变量CLASSPATH中加入
二、JFreeChart配置安装
1、解压jfreechart_0.9.21.zip到指定位置，其中source是jfreechart的源码，jfreechart-0.9.21-demo.jar
是例子程序（该部分留给大家自己去研究）
2、为了配置成功，我们需要关注的文件有如下三个：jfreechart-0.9.21.jar、lib\jcommon-0.9.6.jar、
lib\gnujaxp.jar
3、如果是Application开发，把上述三个文件拷贝到%JAVA_HOME%\LIB中，同时在环境变量CLASSPATH中加入
如果是WEB开发，以TOMCAT中的一个WEB项目TEST为例子说明：
把上述三个文件拷贝到TEST\WEB-INF\LIB中，然后修改TEST\WEB-INF\web.xml文件，在其中加入如下代码：

DisplayChart

org.jfree.chart.servlet.DisplayChart

DisplayChart

/servlet/DisplayChart

至此jfreechart的配置就完成了，下面就可以进行jfreechart的开发了。这里值得提出的是jfreechart的类
结构设计前后兼容性不是很好，不同版本的jfreechart中类库结构可能不一样，有时候可能需要查源码。如果
是中文显示的时候可能依据观感需要改变源码的字体，不过我个人觉得这个版本比以前版本要好一些。

三、JFreeChart功能介绍
JFreeChart目前是最好的java图形解决方案，基本能够解决目前的图形方面的需求，主要包括如下几个方面：
pie charts (2D and 3D)：饼图（平面和立体）
bar charts (regular and stacked, with an optional 3D effect)：柱状图
line and area charts：曲线图
scatter plots and bubble charts
time series, high/low/open/close charts and candle stick charts：时序图
combination charts：复合图
Pareto charts
Gantt charts：甘特图
wind plots, meter charts and symbol charts
wafer map charts
(态图表,饼图(二维和三维) , 柱状图 (水平,垂直),线图,点图,时间变化图,甘特图, 股票行情图,混和图, 温度计图, 刻度图等常用商用图表)
图形可以导出成PNG和JPEG格式，同时还可以与PDF和EXCEL关联
JFreeChart核心类库介绍：
研究jfreechart源码发现源码的主要由两个大的包组成：org.jfree.chart,org.jfree.data。其中前者主要与图形本身有关，后者与图形显示的数据有关。具体研究如果大家有兴趣的话可以自己研究，以后有时间我会告诉大家怎么去研究源码。
核心类主要有：
org.jfree.chart.JFreeChart：图表对象，任何类型的图表的最终表现形式都是在该对象进行一些属性的定制。JFreeChart引擎本身提供了一个工厂类用于创建不同类型的图表对象
org.jfree.data.category.XXXDataSet:数据集对象，用于提供显示图表所用的数据。根据不同类型的图表对应着很多类型的数据集对象类
org.jfree.chart.plot.XXXPlot：图表区域对象，基本上这个对象决定着什么样式的图表，创建该对象的时候需要Axis、Renderer以及数据集对象的支持
org.jfree.chart.axis.XXXAxis：用于处理图表的两个轴：纵轴和横轴
org.jfree.chart.render.XXXRender：负责如何显示一个图表对象
org.jfree.chart.urls.XXXURLGenerator:用于生成Web图表中每个项目的鼠标点击链接
XXXXXToolTipGenerator:用于生成图象的帮助提示，不同类型图表对应不同类型的工具提示类
四、JFreeChart开发（Application/Applet）

one: pie charts

/**

* JfreeChartTest.java

* author:longlong

* May 31, 2007

*/

package com.ghg.java;

import org.jfree.data.general.DefaultPieDataset;

import org.jfree.chart.*;

public class JfreeChartTest {

public static void main(String[] args) {

//创建饼图数据对象

DefaultPieDataset dfp=new DefaultPieDataset();

dfp.setValue("管理人员", 25);

dfp.setValue("市场人员", 35);

dfp.setValue("开发人员", 20);

dfp.setValue("后勤人员", 5);

dfp.setValue("财务人员", 15);

//Create JFreeChart object

JFreeChart a =ChartFactory.createPieChart("CityInfoPort公司组织架构图",dfp, true, true, true);

ChartFrame frame=new ChartFrame ("CityInfoPort公司组织架构图 ",a,true);

frame.pack();

frame.setVisible(true);

}

}

Refactor one

/**

* JfreeChartOne.java

* author:longlong

* May 31, 2007

*/

package com.ghg.java;

import java.awt.Font;

import javax.swing.JPanel;

import org.jfree.chart.ChartFactory;

import org.jfree.chart.ChartPanel;

import org.jfree.chart.JFreeChart;

import org.jfree.chart.plot.PiePlot;

import org.jfree.chart.plot.PlotOrientation;

import org.jfree.data.category.CategoryDataset;

import org.jfree.data.category.DefaultCategoryDataset;

import org.jfree.data.general.DefaultPieDataset;

import org.jfree.data.general.PieDataset;

import org.jfree.ui.ApplicationFrame;

public class JfreeChartOne extends ApplicationFrame {

private static final long serialVersionUID = 1L;

public JfreeChartOne(String s)

{

super(s);

setContentPane(createJPanel());

}

public static void main(String[] args) {

JfreeChartOne one=new JfreeChartOne("CityInfoPort公司组织架构图");

one.pack();

one.setVisible(true);

}

//利用静态方法设定数据源(饼状图)

public static PieDataset createPieDataset() {

DefaultPieDataset defaultpiedataset = new DefaultPieDataset();

defaultpiedataset.setValue("管理人员", 10.02D);

defaultpiedataset.setValue("市场人员", 20.23D);

defaultpiedataset.setValue("开发人员", 60.02D);

defaultpiedataset.setValue("OEM人员", 10.02D);

defaultpiedataset.setValue("其他人员", 5.11D);

return defaultpiedataset;

}

// 通过ChartFactory创建JFreeChart的实例

public static JFreeChart createJFreeChart(PieDataset p)

{

JFreeChart a =ChartFactory.createPieChart("CityInfoPort公司组织架构图",p, true, true, true);

PiePlot pie=(PiePlot )a.getPlot();

pie.setLabelFont(new Font("SansSerif",Font.BOLD,12));

pie.setNoDataMessage("No data available");

pie.setCircular(true);

pie.setLabelGap(0.01D);//间距

return a;

}

public static JPanel createJPanel (){

JFreeChart jfreechart = createJFreeChart(createPieDataset());

return new ChartPanel(jfreechart);

}

}

效果如图所示：

two：创建类别图

/**

* JfreeChartTest.java

* author:longlong

* May 31, 2007

*/

package com.ghg.java;

import org.jfree.data.category.DefaultCategoryDataset;

import org.jfree.data.general.DefaultPieDataset;

import org.jfree.chart.*;

import org.jfree.chart.plot.PlotOrientation;

public class JfreeChartTest {

public static void main(String[] args) {

// 创建类别图（Category）数据对象

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, "广州", "荔枝");

JFreeChart chart=ChartFactory.createBarChart3D("水果产量图", "水果", "水果", dataset, PlotOrientation.VERTICAL, true, true, true);

ChartFrame frame=new ChartFrame ("水果产量图 ",chart,true);

frame.pack();

frame.setVisible(true);

}

}

按照one的重构办法也可以对这个程序实现重构。
当前位置：主页>技术资讯>JSP编程>文章内容

jFreeChart初探-JSP教程,资料/其他
来源：作者：发布时间：2007-12-27

//******************************************
//* author:rautinee *
//* email:rautinee@21cn.com *
//* http://www.tryitsoft.com *
//*本文可自由传播使用，但请务必保留此信息 *
//******************************************

jfreechart也许对大家来说很陌生，她是一款免费的、功能强大的统计图生成工具，能够直接生成png,jpg等各式的文档
为我们java项目的研发增加了一部利器。她的英文简介
jfreechart is a free java class library for generating charts, including:
pie charts;
line charts and horizontal/vertical bar charts (regular and stacked, with optional 3d-effect);
xy plots and scatter plots;
time series, high/low/open/close charts and candle stick charts;
combination charts;
pareto charts;
gantt charts;
bubble charts;
wind plots, meter charts and symbol charts;

正好我最近的一个项目用到她，于是就很粗略的看了一下，现在把他拿出来和大家分享，希望对大家的工作有所
帮助。

本文主要是讲解她在jsp上面的应用。例子采用jsp+javabean结构实现

准备工作：首先我们需要什么？当然是jfreechart的package了，能够在她的官方网站上面找到下载链接
http://www.jfree.org/jfreechart/，把包下下来，配置到tomcat当中，然后能够开始我们的jfreechart之旅
了。

下面我要做的是个饼状统计图，首先建立javabean文档

文档名：tryitshow.java

package com.tryit;

import java.io.*;
import java.awt.insets;
import java.awt.font;
import java.io.printwriter;
import java.text.simpledateformat;
import java.util.iterator;
import java.util.locale;
import java.text.numberformat;
import javax.servlet.http.httpsession;
import org.jfree.data.*;
import org.jfree.chart.*;
import org.jfree.chart.axis.*;
import org.jfree.chart.renderer.verticalbarrenderer;
import org.jfree.chart.renderer.standardxyitemrenderer;
import org.jfree.chart.plot.*;
import org.jfree.chart.entity.*;
import org.jfree.chart.tooltips.*;
import org.jfree.chart.urls.*;
import org.jfree.chart.servlet.*;
import org.jfree.chart.texttitle;
import java.net.url;

public class tryitshow
{
public static string generatepiechart(string infostr, string titles,httpsession session, printwriter pw)
{
string filename = null;
font font;

try {
// 建立piedataset
defaultpiedataset data = new defaultpiedataset();
string ss[]=infostr.split(",");
for (int n=0;n{
string sspart[]=ss[n].split("#");
int tt=integer.parseint(sspart[1]);
string mm=sspart[0];
data.setvalue(mm,tt);
}

// 生成chart物件
pieplot plot = new pieplot(data);
plot.setinsets(new insets(0, 5, 5, 5));

plot.settooltipgenerator(new standardpietooltipgenerator());

font=new font("黑体",font.center_baseline,20);//这个地方是配置统计图标题的字体和大小

jfreechart chart = new jfreechart("",jfreechart.default_title_font, plot, true);

texttitle tt=new texttitle(titles);
tt.setfont(font);
chart.setbackgroundpaint(java.awt.color.white);//统计图片的底色
chart.settitle(tt);

// 把生成的文档写入到临时的目录中
chartrenderinginfo info = new chartrenderinginfo(new standardentitycollection());
filename = servletutilities.savechartaspng(chart, 500, 300, info, session);
//选择存储成png格式的文档，当然您也能够使用savechartasjpeg的方法生成jpg图片

// 把image map 写入到 printwriter
chartutilities.writeimagemap(pw, filename, info);
pw.flush();
}
catch (exception ex) {
system.out.println("error:"+ex.getmessage());
}
return filename;
}
}

接着是jsp文档
<%@ page contenttype="text/html;charset=gb2312"%>
<%@ page import = "com.tryit.tryitshow" %>
<%@ page import = "java.io.printwriter" %>
<%@ page import = "java.text.simpledateformat" %>
<%@ page import = "java.text.parseexception" %>
<%@ page import = "java.util.arraylist" %>
<%@ page import = "java.util.date" %>
<%@ page import = "java.util.iterator" %>
<%@ page import = "java.util.locale" %>

new document

<%
string filename = tryitshow.generatepiechart("本科#100,专科#200","人才学历信息统计",session, new printwriter(out));

string graphurl = request.getcontextpath() + "/servlet/displaychart?filename=" + filename;
%>

" width=500 height=300 border=0 usemap="#<%= filename %>">

ok,大功告成，当然，您能够采用其他方式，比如您能够把dataset的数据配置在xml文档中，从xml文档读取
统计数据中添加百分比等等，还能够选择生成柱状图、折线图等。

jfreechart更有很多其他的用法，希望大家能够多多交流。

web.xml文档的配置

displaychart

org.jfree.chart.servlet.displaychart

displaychart

/servlet/displaychart

import java.awt.Insets;
import java.awt.Image;
import java.io.PrintWriter;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Locale;
import java.text.NumberFormat;
import javax.servlet.http.HttpSession;
import org.jfree.data.*;
import org.jfree.chart.*;
import org.jfree.chart.axis.*;
import org.jfree.chart.renderer.VerticalBarRenderer;
import org.jfree.chart.renderer.StandardXYItemRenderer;
import org.jfree.chart.plot.*;
import org.jfree.chart.entity.*;
import org.jfree.chart.tooltips.*;
import org.jfree.chart.urls.*;
import org.jfree.chart.servlet.*;
import java.awt.Font;

/**
*

Title:

Description:

Company:

* @author jagie
* @version 1.0
*/

public class GSPieChart {
public static void main(String[] args) {
Long[] testData = {
new Long(10), new Long(20), new Long(30), new Long(40)};
generatePieChart(testData, "", null, new PrintWriter(System.out), 580, 250);
}

/**
* 生成图像文件
* @param datas Long[]数组
* @param targetUrl 点饼形图上的扇形，定向到的url
* @param session httpsession
* @param pw PrintWriter
* @param w 生成的图的宽度
* @param h 生成的图的高度
* @return 生成的图像文件的路径
*/

public static String generatePieChart(Long[] datas, String targetUrl,
HttpSession session, PrintWriter pw,
int w, int h) {
String filename = null;
try {

DefaultPieDataset data = new DefaultPieDataset();
data.setValue("正常纳税人", datas[0]);
data.setValue("异常纳税人", datas[1]);
data.setValue("数据不全纳税人", datas[2]);
data.setValue("未处理纳税人", datas[3]);

// Create the chart object
Pie3DPlot plot = new Pie3DPlot(data);
plot.setInsets(new Insets(0, 5, 5, 5));
plot.setForegroundAlpha(0.6f);
plot.setSectionLabelType(plot.NO_LABELS);

plot.setURLGenerator(new StandardPieURLGenerator(targetUrl, "type"));
plot.setToolTipGenerator(new StandardPieToolTipGenerator());
JFreeChart chart = new JFreeChart(
"数据处理结果统计图", JFreeChart.DEFAULT_TITLE_FONT, plot, true);
chart.setTitle(new TextTitle(
"数据处理结果统计图", new Font("黑体", Font.BOLD, 15)));
StandardLegend sl = (StandardLegend) chart.getLegend();
sl.setItemFont(new Font("黑体", Font.TRUETYPE_FONT, 12));

chart.setBackgroundPaint(new java.awt.Color(254, 254, 141));

//因为jfreechart把生成的png文件保存在系统的临时文件夹中，你需要在适当的
//时候调用session.removeAttribute("JFreeChart_Deleter")，这样可以保证png文
//件被删除掉

ChartRenderingInfo info = new ChartRenderingInfo(new
StandardEntityCollection());
filename = ServletUtilities.saveChartAsPNG(chart, w, h, info, session);

// Write the image map to the PrintWriter
ChartUtilities.writeImageMap(pw, filename, info);
pw.flush();

}
catch (Exception e) {
System.out.println("Exception - " + e.toString());
e.printStackTrace(System.out);
filename = "public_error_500x300.png";
}
return filename;
}
}
.........java代码.................

<%

//以下部分为图象输出
String targetUrl="../servlet/gov.gwssi.tax.nspg.
controlservlet.GSMainControlServlet?id="+sid;
Long[] datas={normals,new Long(totalAbnormal),
dataLacks,notProcesses};
String filename=GSPieChart.generatePieChart
(datas,targetUrl,session,new PrintWriter(out),580,250);
String graphURL = request.getContextPath() +
"/servlet/DisplayChart?filename=" + filename;

%>

JFreeChart Hacking
来自于http://www.itepub.net/
<本文允许任意转载，请注明出处！最后一块骨头.2005-05-16>

JFreeChart 是什么？我就不再重复介绍了，网上文章大把...
官方主页：http://www.jfree.org/jfreechart/index.html

<--本文以jfreechart-1.0.0-pre2版本为基准-->

那么为什么要Hacking JFreeChart呢？

罪状一：中文Label显示模糊；
罪状二：无简体中文LocalizationBundle.properties文件；
罪状三：向下兼容性不好，官方说jdk1.2+，其实是jdk1.4+；
兼容问题A：另存菜单输出PNG文件只能运行于jdk1.4+；
兼容问题B：另存菜单不能输出JPEG格式图片；
兼容问题C：jdk1.3-环境下中文ToolTips不能正常显示；

如果一定要加一条罪状的话：目前开源免费的chart项目无出其右；
十分感谢JFreeChart开发者的辛苦努力！虽然它现在还不完美。

Ok，下面为Hacking做一些准备工作...
1.下载jfreechart-1.0.0-pre2.zip解压；
2.将\解压目录\source\下的源码加入任意project并配置jdk&lib；
3.安装一个有批量文件查询/替换功能的工具，比如UtralEdit；

<本文允许任意转载，请注明出处！最后一块骨头.2005-05-16>

Hacking Begin

1.解决中文Label显示模糊问题
原因分析：JFreeChart默认字体对中文的支持不完善；
解决步骤：搜索\解压目录\source\下含有"new Font("的文件；
发现JFreeChart默认字体为
"foo"
"Serif"
"Dialog"
"SansSerif"
"Bitstream Vera Sans"
批量替换他们为任意中文字体（推荐"黑体"）；
当然你也可以把字体写入properties文件，
但这里介绍的是最简单的方法；
然后重新编译你修改过的文件，Ok，搞定！

2.无简体中文LocalizationBundle.properties文件
org\jfree\chart\LocalizationBundle.properties
主要用来显示右键功能菜单的文字，下面我们来汉化：

注意：LocalizationBundle.properties的编码不是Unicode，
简体中文要用GBK编码。

获得GBK编码的方法是：
cd ***\j2sdk1.*.*\bin
native2ascii -encoding GBK 1.txt 2.txt
注：1.txt放中文文本，2.txt输出GBK编码。

# org.jfree.chart.ChartPanel ResourceBundle properties file
#
# Changes (from 31-Aug-2003)
# --------------------------
# 31-Aug-2003 : Initial version (AL);
# 16-May-2005 : Add GBK version (FinalBone);
# 16-May-2005 : Add JPG_Image_Files (FinalBone);

#---------------EN---------------#
#Auto_Range=Auto Range
#All_Axes=Both Axes
#Chart_Properties=Chart Properties
#Copy=Copy
#Print...=Print...
#Save_as...=Save as...
#Properties...=Properties...
#PNG_Image_Files=PNG Image Files
#JPG_Image_Files=JPG Image Files
#Domain_Axis=Domain Axis
#Range_Axis=Range Axis
#Zoom_In=Zoom In
#Zoom_Out=Zoom Out

#---------------GBK---------------#
Auto_Range=\u81ea\u52a8\u8c03\u6574
All_Axes=\u6240\u6709\u5750\u6807\u8f74
Chart_Properties=\u56fe\u8868\u5c5e\u6027
Copy=\u590d\u5236
Print...=\u6253\u5370...
Save_as...=\u53e6\u5b58\u4e3a...
Properties...=\u5c5e\u6027...
PNG_Image_Files=PNG\u56fe\u50cf
JPG_Image_Files=JPG\u56fe\u50cf
Domain_Axis=\u57df\u5750\u6807\u8f74
Range_Axis=\u503c\u5750\u6807\u8f74
Zoom_In=\u653e\u5927
Zoom_Out=\u7f29\u5c0f

另外还有两个同名文件，希望大家有时间也汉化一下。
org\jfree\chart\ui\LocalizationBundle.properties
org\jfree\chart\plot\LocalizationBundle.properties

3.兼容性问题
a.PNG输出问题 b.无JPEG输出菜单
原因分析：javax.imageio.ImageIO这个类只有jdk1.4+才有。
解决步骤：1.打开org.jfree.chart.ChartPanel，
查看doSaveAs()方法，了解其结构；
2.改写doSaveAs()方法，重新编译；
3.如果运行环境是jdk1.3-
打开org.jfree.chart.encoders.SunPNGEncoderAdapter
注释掉javax.imageio.ImageIO，重新编译。

/**
* Updated by FinalBone 2005-5-16 PNG --> JPEG
*
* Opens a file chooser and gives the user an opportunity
* to save the chart in JPEG format.
*
* @throws IOException if there is an I/O error.
*/
public void doSaveAs() throws IOException {

JFileChooser fileChooser = new JFileChooser();
ExtensionFileFilter filter = new ExtensionFileFilter(
localizationResources.getString("JPG_Image_Files"), ".jpg"
);
fileChooser.addChoosableFileFilter(filter);

int option = fileChooser.showSaveDialog(this);
if (option == JFileChooser.APPROVE_OPTION) {
String filename = fileChooser.getSelectedFile().getPath();
if (isEnforceFileExtensions()) {
if (!filename.endsWith(".jpg")) {
filename = filename + ".jpg";
}
}
ChartUtilities.saveChartAsJPEG(
new File(filename), this.chart, getWidth(), getHeight()
);
}

}

c.中文ToolTips不能正常显示（显示为小方框）
原因分析：相关字体找不到。
解决步骤：1.打开org.jfree.chart.block.LabelBlock
查看其构造函数public LabelBlock(String label)；
2.修改构造函数的字体定义，重新编译。

/**
* Creates a new label block.
*
* @param label the label.
*/
public LabelBlock(String label) {
/**
* Updated by FinalBone 2005-05-16
* "Bitstream Vera Sans" --> "黑体"
* For Chinese-Simplified ToolTips
* JDK 1.3- Environment
*/
this(label, new Font("黑体", Font.PLAIN, 11));
}

Hacking End

<本文允许任意转载，请注明出处！最后一块骨头.2005-05-16>

这时的 JFreeChart 才是真正jdk1.2+兼容，完美支持中文。

希望下一版本的 JFreeChart 的字体定义写入properties文件，
并且不同路经下的properties文件最好不要重名。

本人接触 JFreeChart 刚刚几天，错漏难免，请多多指正！

<本文允许任意转载，请注明出处！最后一块骨头.2005-05-16>
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

java中文件操作大全

zxjava — Sat, 17 May 2008 18:17:01 +0800

作者: zxjava 链接：http://zxjava.javaeye.com/blog/193929 发表时间: 2008年05月17日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

一.获得控制台用户输入的信息

/** *//**获得控制台用户输入的信息
* @return
* @throws IOException
*/
public String getInputMessage() throws IOException...{
System.out.println("请输入您的命令∶");
byte buffer[]=new byte[1024];
int count=System.in.read(buffer);
char[] ch=new char[count-2];//最后两位为结束符，删去不要
for(int i=0;i ch[i]=(char)buffer[i];
String str=new String(ch);
return str;
}
可以返回用户输入的信息，不足之处在于不支持中文输入，有待进一步改进。

二.复制文件

1.以文件流的方式复制文件

/** *//**以文件流的方式复制文件
* @param src 文件源目录
* @param dest 文件目的目录
* @throws IOException
*/
public void copyFile(String src,String dest) throws IOException...{
FileInputStream in=new FileInputStream(src);
File file=new File(dest);
if(!file.exists())
file.createNewFile();
FileOutputStream out=new FileOutputStream(file);
int c;
byte buffer[]=new byte[1024];
while((c=in.read(buffer))!=-1)...{
for(int i=0;i out.write(buffer[i]);
}
in.close();
out.close();
}
该方法经过测试，支持中文处理，并且可以复制多种类型，比如txt，xml，jpg，doc等多种格式

三.写文件

1.利用PrintStream写文件

/** *//**
* 文件输出示例
*/
public void PrintStreamDemo()...{
try ...{
FileOutputStream out=new FileOutputStream("D:/test.txt");
PrintStream p=new PrintStream(out);
for(int i=0;i<10;i++)
p.println("This is "+i+" line");
} catch (FileNotFoundException e) ...{
e.printStackTrace();
}
}
2.利用StringBuffer写文件

public void StringBufferDemo() throws IOException......{
File file=new File("/root/sms.log");
if(!file.exists())
file.createNewFile();
FileOutputStream out=new FileOutputStream(file,true);
for(int i=0;i<10000;i++)......{
StringBuffer sb=new StringBuffer();
sb.append("这是第"+i+"行:前面介绍的各种方法都不关用,为什么总是奇怪的问题 ");
out.write(sb.toString().getBytes("utf-8"));
}
out.close();
}
该方法可以设定使用何种编码，有效解决中文问题。

四.文件重命名

/** *//**文件重命名
* @param path 文件目录
* @param oldname 原来的文件名
* @param newname 新文件名
*/
public void renameFile(String path,String oldname,String newname)...{
if(!oldname.equals(newname))...{//新的文件名和以前文件名不同时,才有必要进行重命名
File oldfile=new File(path+"/"+oldname);
File newfile=new File(path+"/"+newname);
if(newfile.exists())//若在该目录下已经有一个文件和新文件名相同，则不允许重命名
System.out.println(newname+"已经存在！");
else...{
oldfile.renameTo(newfile);
}
}
}五.转移文件目录

转移文件目录不等同于复制文件，复制文件是复制后两个目录都存在该文件，而转移文件目录则是转移后，只有新目录中存在该文件。

/** *//**转移文件目录
* @param filename 文件名
* @param oldpath 旧目录
* @param newpath 新目录
* @param cover 若新目录下存在和转移文件具有相同文件名的文件时，是否覆盖新目录下文件，cover=true将会覆盖原文件，否则不操作
*/
public void changeDirectory(String filename,String oldpath,String newpath,boolean cover)...{
if(!oldpath.equals(newpath))...{
File oldfile=new File(oldpath+"/"+filename);
File newfile=new File(newpath+"/"+filename);
if(newfile.exists())...{//若在待转移目录下，已经存在待转移文件
if(cover)//覆盖
oldfile.renameTo(newfile);
else
System.out.println("在新目录下已经存在："+filename);
}
else...{
oldfile.renameTo(newfile);
}
}
}

六.读文件

1.利用FileInputStream读取文件

/** *//**读文件
* @param path
* @return
* @throws IOException
*/
public String FileInputStreamDemo(String path) throws IOException...{
File file=new File(path);
if(!file.exists()||file.isDirectory())
throw new FileNotFoundException();
FileInputStream fis=new FileInputStream(file);
byte[] buf = new byte[1024];
StringBuffer sb=new StringBuffer();
while((fis.read(buf))!=-1)...{
sb.append(new String(buf));
buf=new byte[1024];//重新生成，避免和上次读取的数据重复
}
return sb.toString();
}

2.利用BufferedReader读取

在IO操作，利用BufferedReader和BufferedWriter效率会更高一点

/** *//**读文件
* @param path
* @return
* @throws IOException
*/
public String BufferedReaderDemo(String path) throws IOException...{
File file=new File(path);
if(!file.exists()||file.isDirectory())
throw new FileNotFoundException();
BufferedReader br=new BufferedReader(new FileReader(file));
String temp=null;
StringBuffer sb=new StringBuffer();
temp=br.readLine();
while(temp!=null)...{
sb.append(temp+" ");
temp=br.readLine();
}
return sb.toString();
}

3.利用dom4j读取xml文件

/** *//**从目录中读取xml文件
* @param path 文件目录
* @return
* @throws DocumentException
* @throws IOException
*/
public Document readXml(String path) throws DocumentException, IOException...{
File file=new File(path);
BufferedReader bufferedreader = new BufferedReader(new FileReader(file));
SAXReader saxreader = new SAXReader();
Document document = (Document)saxreader.read(bufferedreader);
bufferedreader.close();
return document;
}

七.创建文件(文件夹)

1.创建文件夹 /** *//**创建文件夹
* @param path 目录
*/
public void createDir(String path)...{
File dir=new File(path);
if(!dir.exists())
dir.mkdir();
}
2.创建新文件 /** *//**创建新文件
* @param path 目录
* @param filename 文件名
* @throws IOException
*/
public void createFile(String path,String filename) throws IOException...{
File file=new File(path+"/"+filename);
if(!file.exists())
file.createNewFile();
}
八.删除文件(目录)

1.删除文件 /** *//**删除文件
* @param path 目录
* @param filename 文件名
*/
public void delFile(String path,String filename)...{
File file=new File(path+"/"+filename);
if(file.exists()&&file.isFile())
file.delete();
}
2.删除目录
要利用File类的delete()方法删除目录时，必须保证该目录下没有文件或者子目录，否则删除失败，因此在实际应用中，我们要删除目录，必须利用递归删除该目录下的所有子目录和文件，然后再删除该目录。 /** *//**递归删除文件夹
* @param path
*/
public void delDir(String path)...{
File dir=new File(path);
if(dir.exists())...{
File[] tmp=dir.listFiles();
for(int i=0;i if(tmp[i].isDirectory())...{
delDir(path+"/"+tmp[i].getName());
}
else...{
tmp[i].delete();
}
}
dir.delete();
}
}
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

javascript 动态创建表格：新增、删除行和单元格

zxjava — Sat, 17 May 2008 17:56:19 +0800

作者: zxjava 链接：http://zxjava.javaeye.com/blog/193926 发表时间: 2008年05月17日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

利用js来动态创建表格有两种格式，appendChild()和insertRow、insertCell()。两种方式其实差不多，但第一种有可能在IE上有问题，所以推荐大家使用第二种了，直接说吧。

1、inserRow()和insertCell()函数

insertRow()函数可以带参数，形式如下：

insertRow(index)：index从0开始

这个函数将新行添加到index的那一行前，比如insertRow(0),是将新行添加到第一行之前。默认的insertRow()函数相当于insertRow(-1)，将新行添加到表的最后。一般我们在使用的时候都是：objTable.insertRow(objTable.rows.length).就是为表格objTable在最后新增一行。

insertCell()和insertRow的用法相同，这里就不再说了。

2、deleteRow()和deleteCell()方法

deleteRow()函数可以带参数，形式如下：deleteRow(index)：index从0开始

和上面两个方法差不多的意思，就是删除指定位置的行和单元格。要传入的参数：Index是行在表格中的位置，可以下面的方法取得然后去删除：

var row=document.getElementById("行的Id");
var index=row.rowIndex;//有这个属性，嘿嘿
objTable.deleteRow(index);

在使用过程中我碰到的一个问题跟大家说一下，就是删除表格的行的时候，如果你删除了某一行，那么表格行数是马上就变化的，所以如果你要删除表格的所有行，下面的代码是错误的：

function clearRow(){
objTable= document.getElementById("myTable");

for( var i=1; i {
tblObj.deleteRow(i);
}
}

这段代码要删除原来的表格的表体，有两个问题。首先不能是deleteRow(i)，应该是deleteRow(1)。因为在删除表格行的时候，表格的行数在变化，这就是问题的关键，rows.length总是在变小，删除的行数总是会比预想的要少一半，所以正确的删除表格的行的代码应该这样：

function clearRow(){
objTable= document.getElementById("myTable");
var length= objTable.rows.length ;
for( var i=1; i {
objTable.deleteRow(i);
}
}

3、动态设置单元格与行的属性

A、采用setAttribute()方法，格式如下：setAttribute(属性，属性值)

说明：这个方法几乎所有的DOM对象都可以使用，第一个参数是属性的名称，比如说：border，第二个就是你要为border设置的值了，比如：1

var objMyTable = document.getElementById("myTable");

objMyTable.setAttribute("border",1);//为表格设置边框为1

其他的比如你要为一个TD设置高度，同样先取得这个TD对象，然后使用setAttribute()方法

var objCell = document.getElementById("myCell");

objCell.setAttribute("height",24);//为单元格设置高度为24

在使用的时候遇到一个设置样式的问题，不能用setAttribute("class","inputbox2");而应该使用setAttribute("className","inputbox2")，呵呵，其他我估计也有同样的问题，有些属性和我们在DW里面的不一致，呵呵，大家自己摸索吧。

B、直接赋值

var objMyTable = document.getElementById("myTable");

objMyTable.border=1;//为表格设置边框为1

这个方法也全部适用，呵呵。

4、创建表格

了解了行与单元格的增删那就可以创建表格了。

第一步：你需要有一个你去动态变化的表格，我这里讲的是已经存在页面的表格，我们要设置一个id:myTable

var objMyTable = document.getElementById("myTable");

第二步：创建行与列的对象

var index = objMyTable.rows.length-1;
var nextRow = objMyTable.insertRow(index);//要新增的行，我这里是从倒数第二行开始新增的

//单元格箱号
var newCellCartonNo = nextRow.insertCell();
var cartonNoName = "IptCartonNo";
newCellCartonNo.innerHTML = " ";
newCellCartonNo.setAttribute("className","tablerdd");

这样就搞定了，可以简单的创建一个行和列了。具体的代码我贴在下面。只是很简单的例子，不过方法就大概是上面的了，呵呵，慢慢摸索吧~

蓝光-BlueShine

第1行

5、appendChild()方法

我就直接贴代码了，大家去研究，时间紧，哈哈，见谅~

My Test Page

My Test Page

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

dwr中的util.js应用

zxjava — Sat, 17 May 2008 17:17:20 +0800

作者: zxjava 链接：http://zxjava.javaeye.com/blog/193912 发表时间: 2008年05月17日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

util.js包含一些有用的函数function,用于在客户端页面调用，它可以和dwr分开，独立营用于你的系统中。
主要功能如下：
1、$() 获得页面参数值
2、addOptions and removeAllOptions 初始化下拉框
3、addRows and removeAllRows 填充表格
4、getText 取得text属性值
5、getValue 取得form表单值
6、getValues 取得form多个值
7、onReturn
8、selectRange
9、setValue
10、setValues
11、toDescriptiveString
12、useLoadingMessage
13、Submission box
***************************************************************************************
//////////////////////////////////////////////////////////////////////////////////////
****************************************************************************************
1、$()函数
IE5.0 不支持
$ = document.getElementById
取得form表单值
var name = $("name");
***************************************************************************************
//////////////////////////////////////////////////////////////////////////////////////
****************************************************************************************
2、用于填充 select 下拉框 option
a、如果你想在更新select 时，想保存原来的数据，即在原来的select中添加新的option：
var sel = DWRUtil.getValue(id);
DWRUtil.removeAllOptions(id);
DWRUtil.addOptions(id,...);
DWRUtil.setValue(id,sel);
demo:比如你想添加一个option：“--请选择--”
DWRUtil.addOptions(id,["--请选择--"]);
DWRUtil.addOptions()有5中方式：
@ Simple Array Example: 简单数组
例如:
Array array = new Array[ 'Africa', 'America', 'Asia', 'Australasia', 'Europe' ]；
DWRUtil.addOptions("demo1",array);
@ Simple Object Array Example 简单数组,元素为beans
这种情况下,你需要指定要显示 beans 的 property 以及对应的 bean 值
例如:
public class Person {
private String name;
private Integer id;
pirvate String address;
public void set(){……}
public String get(){……}
}
DWRUtil.addOptions("demo2",array,'id','name');
其中id指向及bean的id属性，在optiong中对应value，name指向bean的name属性，对应下拉框中显示的哪个值.
@ Advanced Object Array Example 基本同上
DWRUtil.addOptions( "demo3",
[{ name:'Africa', id:'AF' },
{ name:'America', id:'AM' },
{ name:'Asia', id:'AS' },
{ name:'Australasia', id:'AU' },
{ name:'Europe', id:'EU' }
],'id','name');
@ Map Example 用制定的map来填充 options:
如果 server 返回 Map,呢么这样处理即可：
DWRUtil.addOptions( "demo3",map);
其中 value 对应 map keys，text 对应 map values；
@

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐