一： JFreeChart 简介：
JFreeChart是开放源代码项目，它主要用来各种各样的图表，这些图表包括：饼图、柱状图(普通柱状图以及堆栈柱状图)、线图、区域图、分布图、混合图、甘特图以及一些仪表盘等等。
一.JFreeChart创建WEB图表的基本知识
JFreeChart主要是由三个类构成：
org.jfree.chart.servlet.ChartDeleter
org.jfree.chart.servlet.DisplayChart
org.jfree.chart.servlet.ServletUtilities
在下面做一下简单的介绍：
ChartDeleter 继承自HttpSessionBindingListener，用于实现当Session 关闭时，删除
临时目中的图象文件。
ServletUtilities有一系列方法：
saveChartAs*;saveChartAs*是把图表按照不同的形式存储为图象；
sendTempFile方法被重载了很多次，用于把文件流发送response;
DisplayChart继承自Httpservlet 用于处理显示图象；

二：webwork简介及webwork，JFreeChart应用环境的配置
WebWork是一个源代码开放的Web应用框架，用于简化基于Web的应用开发。
WebWork的最大优点是它的简单性和灵活性。WebWork有一个很小的API，它使开发者可以迅速进行开发工作。
WebWork是许多特性和适用性的组合，包括使用variour view技术，
例如JavaServer Pages(JSP),Velocity,Extensible Stylesheet Language Transformations
Specification(XSLT)和JasperReporters。还有，webwork对JFreechart有非常好的支持。
从这里下载webwork-2.0-beta2.zip。
(https://webwork.dev.java.net/servlets/ProjectDocumentList)
解压缩文件，你可以在webwork-2.0\lib\optional目录下找到jfreechart-0.9.13.jar。
你也可以从这里下载最新的jfreechart-0.9.15.zip。
（http://www.jfree.org/jfreechart/index.html）
本文使用的是jfreechart-0.9.15.zip。
web应用的目录结构图如下所示：
/webapp/WEB-INF
/webapp/WEB-INF/web.xml
/webapp/WEB-INF/webwork.tld
/webapp/WEB-INF/classes
/webapp/WEB-INF/classes/xwork.xml
/webapp/WEB-INF/lib
接下来请务必将下面这些包放在/webapp/WEB-INF/lib 目录下。
1。commons-logging.jar
2。ognl-2.5.1.jar
3。oscore-2.2.1.jar
4。xwork-1.0-beta.jar
5。webwork-2.0-beta.jar
下面是可以选择的包，具体根据项目需要来决定是否添加：
cos-multipart.jar
pell-multipart.jar
velocity-dep-1.3.jar
2.1 配置你的xwork.xml
文件像下面例子一样，注意一定要包含webwork-default.xml。
<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN"

"http://www.opensymphony.com/xwork/xwork-1.0.dtd">
<xwork>
    <include file="webwork-default.xml"/>  
   <package name="default" extends="webwork-default">
    ...
    </package>
</xwork>

webwork-default.xml这个文件在webwork-2.0-beta.jar里面。
2.2 修改web.xml文件
修改web.xml文件以包含webwork的设置，如何设置的内容，请察看
$WEBWORK/src/resource/web/WEB-INF/web.xml文件。
2.3 Taglib部分的选择
如果你不打算使用taglib、Velocity、或者XSLT，仅仅只需要在web.xml中不要包含这些内容就可以了。
2.4 Log的设置
Webwork使用log4j，如果你的app server没有安装log4j，你需要增加log4j，复制log4j.jar文件到合适的lib目录。如果你使用tomcat，那么安装目录是$TOMCAT_HOME\lib，当然也可以安装到你的web应用的路径。但需要注意的是如果appserver也适用log4j，你需要小心版本冲突。
2.5 解压缩jfreechart-0.9.15.zip
jfreechart-0.9.15目录下的jfreechart-0.9.15.jar和lib/jcommon-0.9.0.jar,lib/gnujaxp.jar都是开发运行需要的文件，把这三个文件放置到/webapp/WEB-INF/lib目录下。

三 JFreeChart在webwork中的应用的具体例子
在进行上面的步骤后，我们将要进行具体的开发过程。
步骤：首先在xwork.xml -定义result-types
   <result-types>
   <result-type name="chart" class="pawpaw.test.ChartResult"/>
   </result-types>

   然后在xwork.xml - 定义action
<action name="viewModerationChart" class="pawpaw.test.ViewModerationChartAction">
  <result name="success" type="chart">
    <param name="width">400</param>
    <param name="height">300</param> </result>
</action>

其中param里面定义的是chart图表的长宽。
然后在web.xml文件中增加以下内容：
    <servlet>
        <servlet-name>DisplayChart</servlet-name>
        <servlet-class>org.jfree.chart.servlet.DisplayChart</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>DisplayChart</servlet-name>
        <url-pattern>/servlet/DisplayChart</url-pattern>
    </servlet-mapping>

部分源代码如下：
package pawpaw.test;

import com.opensymphony.webwork.ServletActionContext;
import com.opensymphony.xwork.ActionInvocation;
import com.opensymphony.xwork.Result;
import org.jfree.chart.ChartUtilities;
import org.jfree.chart.JFreeChart;
import java.io.OutputStream;
import javax.servlet.http.HttpServletResponse;
/*
 * <p>Description: 把chart文件流换成是通过HttpServletResponse
 *    对象获取到的输出流在浏览器中输出</p>
 * author: pawpaw
 * @version 1.0  12/15/2003
 */
public class ChartResult implements Result {
    JFreeChart chart;
    boolean chartSet = false;
    private int height;
    private int width;

    public void setChart(JFreeChart chart) {
        this.chart = chart;
        chartSet = true;
    }
    //设置图片的长度
    public void setHeight(int height) {
        this.height = height;
    }
    //设置图片的宽度
    public void setWidth(int width) {
        this.width = width;
    }

    public void execute(ActionInvocation invocation) throws Exception {
        JFreeChart chart = null;

        if (chartSet) {
            chart = this.chart;
        } else {
            chart = (JFreeChart) invocation.getStack().findValue("chart");
        }

        if (chart == null) {
            throw new NullPointerException("No chart found");
        }
       
        //把文件流换成是通过HttpServletResponse对象获取到的输出流
        HttpServletResponse response = ServletActionContext.getResponse();
        OutputStream os = response.getOutputStream();
        ChartUtilities.writeChartAsPNG(os, chart, width, height);
        os.flush();
    }
}

创建JFreeChart的action类。
package pawpaw.test;

import java.awt.Insets;
import java.awt.Font;
import java.io.PrintWriter;
import javax.servlet.http.HttpSession;
import org.jfree.data.*;
import org.jfree.chart.*;
import org.jfree.chart.plot.*;
import org.jfree.chart.entity.*;
import org.jfree.chart.urls.*;
import org.jfree.chart.servlet.*;
import org.jfree.chart.labels.StandardPieToolTipGenerator;
import org.jfree.util.Rotation;
import com.opensymphony.xwork.ActionSupport;
/*
 *<p>Description: 输出一条斜线chart</p>
 * author: pawpaw
 * @version 1.0  12/15/2003
 */
public class ViewModerationChartAction extends ActionSupport {  
   private JFreeChart chart;
   public String execute() throws Exception {
      // 创建chart文件数据集
      XYSeries dataSeries = new XYSeries(null);
      for (int i = 0; i <= 100; i++) {
         dataSeries.add(i, RandomUtils.nextInt());
      }
      XYSeriesCollection xyDataset = new XYSeriesCollection(dataSeries);
            ValueAxis xAxis = new NumberAxis("Raw Marks");//x轴坐标
      ValueAxis yAxis = new NumberAxis("Moderated Marks");//y轴坐标    
      // 设置chart的样式
      chart =new JFreeChart(
            "Moderation Function",// 图表标题
            JFreeChart.DEFAULT_TITLE_FONT,
            new XYPlot(
               xyDataset,
               xAxis,
               yAxis,
               new                        
           StandardXYItemRenderer(StandardXYItemRenderer.LINES)),// 数据集
            false    //是否生成URL链接
            );
      chart.setBackgroundPaint(java.awt.Color.white);  //设置图片的背景色
      Font font = new Font("黑体",Font.CENTER_BASELINE,20);//设置图片标题的字体和大小
      TextTitle _title = new TextTitle(title);
      _title.setFont(font);
      chart.setTitle(_title);
      return super.SUCCESS;
   }  
   public JFreeChart getChart() {
      return chart;
   }
}

小结：这只是一个简单的例子，如果你想深入了解的话，可以参考webwork文档和jfreechart网站。
参考资料：
http://www.jfree.org/jfreechart/index.html
webwork英文文档

     我们现在已经拥有了支持部件的工具包，让我们从使用JavaMail发送简单的电子邮件开始讲解，我们将提出所有的设置放到一个单独的静态类MailSettings当中，这样做将在比较代码的时候容易些。

     在发送电子邮件之前，您还需要知道SMTP服务器的主机名，SMTP服务器是负责将您的邮件发送到外部世界去的机器。

     JavaMail使用了Session类的概念来保存诸如SMTP主机和认证的信息，主要想法是基于会话（Sessions）在Java虚拟机中可以被隔离，这可以阻止恶意代码窃取其他用户在其他会话中的信息，这些信息可能包括用户名和密码等认证信息。“但是”，您可能会说，“在同一时间，我只在Java虚拟机上运行一个应用程序，而且我相信我的代码。”JavaMail的目的是开发大型的邮件系统，它有一个具有复杂性的关联层，您可以绕过没有经验的用户，我们用以下的例子来说明：

Properties props=new Properties();
props.put("mail.smtp.host",MailSettings.smtpHost);
Session session=Session.getDefaultInstance(props,null);

     此处，并没有创建新的会话，您只是从会话工厂（session factory）中得到并通过Properties的实例来进行设置，我们只对SMTP主机进行了设置和传送，在得到默认的实例的同时创建了一个共享的会话，现在我们可以使用这个会话来创建邮件消息了。

Message message=new MimeMessage(session);

     JavaMail中有一个Message类，各种各样的消息都是它的子类，如果查看了JavaMail的API，您会发现它只有一个子类：MimeMessage。JavaMail是被设计为通用的电子邮件框架的，所以显然存在冗余的抽象。总之，我们已经使用会话创建了一个MimeMessage，现在我们需要来填充这个消息。

message.setFrom(new InternetAddress (MailSettings.fromAddress, MailSettings.fromName));

     再次利用抽象，JavaMail有一个Address（地址）类，其他所有的地址类型皆源于此，但是我们现在只关心发送国际互联网的电子邮件，所以我们制造一个InternetAddress，这个地址用来表示电子邮件的来源和一个用于显示的“个人”名字。现自我们来设置邮件将发向何方。

message.setRecipient(Message.RecipientType.TO, new InternetAddress(MailSettings.toAddress));

     地址的抽象将再次出现，我们设定接收器和接收器的类型，从此处开始，至少纯文本的电子邮件可以稳定地传送了，我们只需要设定邮件的标题、信文并打上时间戳。

message.setSubject(MailSettings.messageSubject);
message.setText(MailSettings.messageBody1);
message.setSentDate(new Date());

     此时，我们已经准备好发送消息了。

Transport.send(message);

     这个对Transport类的调用将会去查找适当的会话，并找出如何发送消息，尽管这样做看上去有些不直观。当我们完成这一步的时候，我们的邮件就已经发送出去了。此时，我们还需要添加代码来捕获三种JavaMail可能抛出的异常，它们是AddressException、MessagingException和UnsupportedEncodingException. 但这就是最基本的使用JavaMail发送邮件的方法。

     现在，让我们来看看如何使用Apache的通用电子邮件软件包（参见MailCommons.java）来完成同样的工作，通用电子邮件库是一系列类的集合，它们基于您所要发送的邮件类型，其中最简单的是SimpleEmail类，不需要建立任何会话或属性列表：

SimpleEmail email=new SimpleEmail();
email.setHostName(MailSettings.smtpHost);

     以上代码创建了我们的邮件并指定它通过我们选定的SMTP服务器发送，因为通用电子邮件库只处理国际互联网的电子邮件，所以就不必在创建InternetAddress实例上浪费时间了，我们可以简单地设定来源地址：

email.setFrom(MailSettings.fromAddress,MailSettings.fromName);

     我们只需要添加一个地址到收信人列表当中，而不是发送接收器的类型：

email.addTo(MailSettings.toAddress);

     同样，设定邮件的标题和信文与发送邮件都很简单。

email.setSubject(MailSettings.messageSubject);
email.setMsg(MailSettings.messageBody1);
email.send();

     我们所需要去捕获的异常只有EmailException这一种，所以，您应该可以看出通过隐藏所有的框架和会话管理，事情变得非常简单并且代码更容易阅读。

     当然，这是我们所能发送的最简单的电子邮件，我们假设SMTP服务器不需要认证，我们发送的邮件只有一个收件人，并没有发送邮件副本。让我们先来看看认证，SMTP认证（SMTP AUTH）需要用户名和密码来发送邮件，在JavaMail中（参见MailJavaMail2.java），需要创建一个认证者（Authenticator）来返回所需的认证证书：

class ForcedAuthenticator extends Authenticator {
public PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(MailSettings.smtpUsername,
MailSettings.smtpPassword);
}
}

     当我们创建会话的时候，就给出这个认证者的一个实例。

Session session=Session.getDefaultInstance(props,new ForcedAuthenticator());

     然而，这里有一点要注意，这种做法将默认的会话绑定到了该认证者，因此您需要一个指向它的引用（reference）以再次取得这个会话。当然，您也可以转而使用Session.getInstance()，来创建一个唯一的不共享的实例，但是这将依靠您自己来管理会话的实例。

     现在让我们来看看如果使用通用电子邮件库的方法来进行认证（参见MailCommons2.java），您将只看到一行新的语句：

email.setAuthentication(MailSettings.smtpUsername,MailSettings.smtpPassword);这就解决了认证过程的所有痛苦。

     还有另外一种认证方式，那就是使用在邮件服务中的POP-before-SMTP，它并没有实现SMTP AUTH，其实SMTP AUTH是SMTP之后的一种扩展，而POP-before-SMTP的工作方式则是将受密码控制的邮件接收者和发送邮件的能力进行绑定，只有当用户经过POP协议访问某个受密码保护的POP邮件服务器一段时间之后，此用户才能够发送邮件。在JavaMail中，为了发送邮件，你需要编写打开POP信箱的代码，这将涉及JavaMail接收端的工作，我们将在下一篇文章中讲解相关内容；而对于通用电子邮件库来讲，事情就容易得多了：

email.setPopBeforeSMTP(true,popHost,popUsername,popPassword);

     这使您可以操作与POP-before-SMTP相关的所有功能，而根本不需要考虑处理与POP相关的工作。

     让我们再来看看如何设定邮件的抄送收件人，现在JavaMail的Message类有一个setRecipients方法，该方法可以接受一个InternetAddress的数组，但这样做并不精巧，如果您已经有了一个储存电子邮件地址的字符串数组，那就可以结束这种复杂方法的考验。

ArrayList ccs=new ArrayList();
for(String s:MailSettings.ccAddresses) ccs.add(new InternetAddress(s));
message.setRecipients(Message.RecipientType.CC,
(InternetAddress[]) ccs.toArray(new InternetAddress[ccs.size()]));

     现在让我们来看看通用电子邮件库，我们发现了两件事情：首先，setTo、setCc和setBcc方法都使用了InternetAddress的集合作为它们的参数，这样做更符合Java的现行实践；其次，addTo、addCc和addBcc方法将创建和添加收件人列表变得轻松。（参见MailCommons3.java）

for(String s:MailSettings.ccAddresses) email.addCc(s);

     这样的代码更加清晰。

     最后，让我们来看看如何发送包含内嵌图片的HTML格式的电子邮件，在此，JavaBeans激活框架将与JavaMail将协同工作，来协助图片的编码。在JavaMail的API中，我们首先创建一个MimeMultipart的实例，然后创建MimeBodyParts的实例，并将它们组装到MimeMultipart的实例中，所以，嵌入单个图片，比如uk-builder-com.gif这个图片文件，并将它显示在HTML消息中，我们需要完成以下步骤（参见HtmlJavaMail.java）

MimeMultipart multipart=new MimeMultipart();
BodyPart msgBodyPart=new MimeBodyPart();
msgBodyPart.setContent("<H1>Hi! From HtmlJavaMail</H1>
<img src=\"cid:logo\">","text/html");
BodyPart embedImage=new MimeBodyPart();
DataSource ds=new URLDataSource(new URL(MailSettings.inlineImage));
embedImage.setDataHandler(new DataHandler(ds));
embedImage.setHeader("Content-ID","");
multipart.addBodyPart(msgBodyPart);
multipart.addBodyPart(embedImage);
message.setContent(multipart);

     第一个BodyPart将它的内容设置为一个字符串和“text/html”的内容类型，注意，在我们设置的HTML代码中，IMG标签指向了一个内容标识符（content-id），这就是MIME（多用途互联网邮件扩充协议）消息部分的名称，该消息将含有GIF格式的标识图文件，为了嵌入这个图片，我们创建了另一个BodyPart和一个JAF的数据源（data source），JAF类库将负责管理内容的工作；然后我们将使用这个DataSource在BodyPart上添加一个DataHandler（数据处理器），这样就可以读出我们的URL所指向的内容了。最后，我们还要在BodyPart的头部设定Content-ID，这样它就可以作为内嵌图片被访问了。我们创建的那些BodyParts将被添加到MimeMultipart的实例中，为此，我们使用setContent（）方法而不是调用setText（）方法。最棘手的部分莫过于管理这些内容标识符了，我们在此只完成了嵌入一个图片的工作，但今后每添加一个图片，您都需要在HTML中加入一个BodyPart和一个内容标识符。

     现在让我们来看看使用通用电子邮件库方法的版本（参见HtmlMailCommons.java）：

HtmlEmail email=new HtmlEmail();…
String cid=email.embed(new URL(MailSettings.inlineImage),"Builder AU Logo");
email.setHtmlMsg("<H1>Hi! From MailJavaMail3</H1><img src=\"cid:"+cid+"\">");
email.setTextMsg("Your email client does not support HTML messages, sorry");

     这种方法简短了很多，而且这一版本拥有更多的功能：当电子邮件客户端不能处理HTML时，它将显示备用的文字。我们从创建一个SimpleEmail实例改变为创建一个HtmlEmail实例。为了嵌入一个图片，我们只需要简单地调用HtmlEmail的嵌入方法，这将返回一个字符串，该字符串含有被生成和管理的内嵌图片内容标识符的信息，我们可以直接使用这些信息来生成HTML内容。我们只需要简单地对适当的字符串调用setHtmlMsg方法来进行设定，setTextMsg将设定不支持HTML的客户端所显示的文字，然后我们就可以发送邮件了。

     但是，到目前为止，您可能正在想“直接使用JavaMail的意义是什么呢？”答案是，如果您的目的是发送电子邮件，那么对于大多数情况，通用电子邮件库仅仅需要少量的复杂代码就可以完成您的需求，但是它连一点控制邮件会话和接收邮件的功能都没有，如果您的应用软件不需要大规模地进行邮件转换或邮件阅读的操作，那么应该不会造成不便。当然，如果您需要进行上述操作，那您就已经在使用JavaMail库了。这里唯一的一个警告就是，在我写这篇文章之时，通用电子邮件库发布的是1.0版本，其API中可能有一些缺陷和漏洞，但它确实可以工作。现在您应该没有借口不让您的应用软件在工作的时候发送状态邮件了。

您可以下载这篇文章的源代码

查看本文的国际来源

摘要:

/*
 * Created on 2006-1-12 Person.java
 * @author 
 */
package test.annotation.validator;

import org.hibernate.validator.Length;
import org.hibernate.validator.Min;
import org.hibernate.validator.Valid;
　

//@Serializability  //测试自定义约束
public class Person {

  private String name;
  private int age;
  private Address address;
  
  public Person() {}
  
  @Valid //注意此处
  public Address getAddress() {
    return address;
  }
  public void setAddress(Address address) {
    this.address = address;
  }
  
  @Min(value = 1)
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }
  
  @Length(min = 4)
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
} 

/*
 * Created on 2006-1-12 Address.java
 * @author 
 */
package test.annotation.validator;

import org.hibernate.validator.Length;
import org.hibernate.validator.Max;
import org.hibernate.validator.Min;

public class Address {

  private String street;
  private int num;
  
  public Address() {}
  
  @Min(value = 1)
  @Max(value = 100)
  public int getNum() {
    return num;
  }
  public void setNum(int num) {
    this.num = num;
  }
  
  @Length(min = 3,max = 8)
  public String getStreet() {
    return street;
  }
  public void setStreet(String street) {
    this.street = street;
  }
} 

/*
 * Created on 2006-1-12
 * @author icerain
 */
package test.annotation.validator;

import org.hibernate.validator.ClassValidator;
import org.hibernate.validator.InvalidValue;


public class TestValidator {
  public void test() {
    Address add = new Address();
    add.setNum(0);
    add.setStreet("1");
    
    Person p = new Person();
    p.setAddress(add);
    p.setAge(0);
    p.setName("ice");
    
    /******************Test validator ********/
    // 注意该处只验证了Person 为了说明 @Valid 注释的使用
    ClassValidator<Person> classValidator = new ClassValidator<Person> (Person.class);
    InvalidValue[] validMessages = classValidator.getInvalidValues(p);
    for (InvalidValue value : validMessages) {
      
    System.out.println("InvalidValue 的长度是:" + validMessages.length
        +" . 验证消息是: " + value.getMessage() 
        + " . PropertyPath 是:" + value.getPropertyPath()
        +" .\n\t PropertyName 是: " +value.getPropertyName()
        + "Value 是: " + value.getValue()
        +" Bean 是: "+ value.getBean()
        +"\n\t BeanClass 是:" + value.getBeanClass());
    }
  }
  
  public static void main(String[] args) {
    new TestValidator().test();
  }
}

package test.annotation.validator;

import java.lang.annotation.Documented;
import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import java.lang.annotation.Retention;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Target;

import org.hibernate.validator.ValidatorClass;

/**
 * Dummy sample of a bean-level validation annotation
 *
 * @author Emmanuel Bernard
 */
@ValidatorClass(SerializabilityValidator.class)
@Target({METHOD,FIELD,TYPE})
@Retention(RUNTIME)
@Documented
public @interface Serializability {
  int num() default 11; 
  String message() default "bean must be serialiable";
} 

@ValidatorClass(SerializabilityValidator.class) 指出了 constraint validator 类.

@Target({METHOD,FIELD,TYPE})
@Retention(RUNTIME)
@Documented 

//$Id: SerializabilityValidator.java,v 1.3 2005/11/17 18:12:11 epbernard Exp $
package test.annotation.validator;

import java.io.Serializable;

import org.hibernate.validator.Validator;

/**
 * Sample of a bean-level validator
 *
 * @author Emmanuel Bernard
 */
public class SerializabilityValidator implements Validator<Serializability>, Serializable {
  public boolean isValid(Object value) {
   //这里只是Validator 里面的 实现验证规则的 方法. value 是要验证的值.
    System.out.println("IN SerializabilityValidator isValid:"+value.getClass()+": " +value.toString()); 
    return value instanceof Serializable;
  }

  public void initialize(Serializability parameters) {
    // 在这里可以 取得 constraint descriptor 里面的属性 如上面我们声明的 num 
    System.out.println("IN SerializabilityValidator: parameters:"+ parameters.num() );
  }
} 

public @interface Serializability {
  int num() default 11; 
  String message() default "{Serializable}"; //"bean must be serialiable"; //消息的国际化
}

import java.lang.annotation.Annotation;

/**
 * A constraint validator for a particular annotation
 *
 * @author Gavin King
 */
public interface Validator<A extends Annotation> {
  /**
   * does the object/element pass the constraints
   */
  public boolean isValid(Object value);

  /**
   * Take the annotations values
   * @param parameters
   */
  public void initialize(A parameters);
}

import java.io.Serializable;

/**
 * A single violation of a class level or method level constraint.
 *
 * @author Gavin King
 */
public class InvalidValue implements Serializable {
  private final String message;
  private final Object value;
  private final String propertyName;
  private final Class beanClass;
  private final Object bean;
  private Object rootBean;

  public Object getRootBean() {
    return rootBean;
  }

  public String getPropertyPath() {
    return propertyPath;
  }

  private String propertyPath;

  public InvalidValue(String message, Class beanClass, String propertyName, Object value, Object bean) {
    this.message = message;
    this.value = value;
    this.beanClass = beanClass;
    this.propertyName = propertyName;
    this.bean = bean;
    this.rootBean = bean;
    this.propertyPath = propertyName;
  }

  public void addParentBean(Object parentBean, String propertyName) {
    this.rootBean = parentBean;
    this.propertyPath = propertyName + "." + this.propertyPath;
  }

  public Class getBeanClass() {
    return beanClass;
  }

  public String getMessage() {
    return message;
  }

  public String getPropertyName() {
    return propertyName;
  }

  public Object getValue() {
    return value;
  }

  public Object getBean() {
    return bean;
  }

  public String toString() {
    return propertyName + ' ' + message;
  }

} 

/**
 * Engine that take a bean and check every expressed annotation restrictions
 *
 * @author Gavin King
 */
public class ClassValidator<T> implements Serializable {
  private static Log log = LogFactory.getLog( ClassValidator.class );
  private static final InvalidValue[] EMPTY_INVALID_VALUE_ARRAY = new InvalidValue[]{};
  private final Class<T> beanClass;
  private transient ResourceBundle messageBundle;
  private transient boolean defaultResourceBundle;

  private final transient Map<Class, ClassValidator> childClassValidators;
  private transient List<Validator> beanValidators;
  private transient List<Validator> memberValidators;
  private transient List<Member> memberGetters;
  private transient Map<Validator, String> messages;
  private transient List<Member> childGetters;
  private static final String DEFAULT_VALIDATOR_MESSAGE = "org.hibernate.validator.resources.DefaultValidatorMessages";


  /**
   * create the validator engine for this bean type
   */
  public ClassValidator(Class<T> beanClass) {
    this( beanClass, null );
  }

  /**
   * create the validator engine for a particular bean class, using a resource bundle
   * for message rendering on violation
   */
  public ClassValidator(Class<T> beanClass, ResourceBundle resourceBundle) {
    this( beanClass, resourceBundle, new HashMap<Class, ClassValidator>() );
  }

  protected ClassValidator(
      Class<T> beanClass, ResourceBundle resourceBundle, Map<Class, ClassValidator> childClassValidators
  ) {
    this.beanClass = beanClass;
    this.messageBundle = resourceBundle == null ?
        getDefaultResourceBundle() :
        resourceBundle;
    this.childClassValidators = childClassValidators;
    initValidator( beanClass, childClassValidators, this.messageBundle );  //重要的是该初始化函数
  }

  private ResourceBundle getDefaultResourceBundle() {
    ResourceBundle rb;
    try {
      rb = ResourceBundle.getBundle( "ValidatorMessages" );
    }
    catch( MissingResourceException e) {
      //the user did not override the default ValidatorMessages
      log.debug( "ResourceBundle ValidatorMessages not found. Delegate to " + DEFAULT_VALIDATOR_MESSAGE);
      rb = ResourceBundle.getBundle( DEFAULT_VALIDATOR_MESSAGE );
    }
    defaultResourceBundle = true;
    return rb;
  }

  private void initValidator(
      Class<T> beanClass, Map<Class, ClassValidator> childClassValidators,
      ResourceBundle resourceBundle
  ) {
    beanValidators = new ArrayList<Validator>(); // 保存类级别的验证约束实现类
    memberValidators = new ArrayList<Validator>(); // 保存方法级别的验证约束实现类
    memberGetters = new ArrayList<Member>();// 保存类的成员(字段or方法)和构造函数方法的标识信息
    messages = new HashMap<Validator, String>(); // 利用Map保存与每个Validator相对应的验证消息
    childGetters = new ArrayList<Member>();//  保存子类的成员(字段or方法)和构造函数方法的标识信息

    childClassValidators.put( beanClass, this ); //map Map<Class, ClassValidator> childClassValidators;
    Annotation[] classAnnotations = beanClass.getAnnotations();
    for ( int i = 0; i < classAnnotations.length ; i++ ) {
      Annotation classAnnotation = classAnnotations[i];
     Validator beanValidator = createValidator( classAnnotation );//根据Annotation来得到Validator,参考对该函数的解释
      if ( beanValidator != null ) beanValidators.add( beanValidator );//保存该Validator
    }
    //build the class hierarchy to look for members in
    Collection<Class> classes = new HashSet<Class>();
    addSuperClassesAndInterfaces( beanClass, classes );//把beanClass的所有超类和实现的接口添加的集合classes中

    //Check on all selected classes
    for ( Class currClass : classes ) {
      Method[] methods = currClass.getDeclaredMethods();// 扫描Method上面的注释
      for ( int i = 0; i < methods.length ; i++ ) {
        Method method = methods[i];
        createMemberValidator( method ); // 创建方法上的约束实现类(Validator), 参考对该函数的解释
        Class clazz = method.getReturnType();// 得到该方法的返回类型
        createChildValidator( resourceBundle, method, clazz );// 创建子类的Validator
      }

      Field[] fields = currClass.getDeclaredFields(); // 扫描Field上面的注释, 下面和上面Method的实现一样
      for ( int i = 0; i < fields.length ; i++ ) {
        Field field = fields[i];
        createMemberValidator( field );
        Class clazz = field.getType();
        createChildValidator( resourceBundle, field, clazz );
      }
    }
  }

  private void addSuperClassesAndInterfaces(Class clazz, Collection<Class> classes) {
    for ( Class currClass = clazz; currClass != null ; currClass = currClass.getSuperclass() ) {
      if ( ! classes.add( currClass ) ) return;
      Class[] interfaces = currClass.getInterfaces();
      for (Class interf : interfaces) {
        addSuperClassesAndInterfaces( interf, classes );
      }
    }
  }

  /**
   * 创建内嵌类的Validator. 如果该内嵌类被Valid Annotation 注释的话则 
   * 创建另外一个ClassValidator
   * @param resourceBundle
   * @param member
   * @param clazz
   */
  private void createChildValidator(ResourceBundle resourceBundle, Member member, Class clazz) {
    if ( ( (AnnotatedElement) member ).isAnnotationPresent( Valid.class ) ) {
      setAccessible( member );
      childGetters.add( member );
      if ( !childClassValidators.containsKey( clazz ) ) {
        new ClassValidator( clazz, resourceBundle, childClassValidators );
      }
    }
  }

  /**
   * 利用传入的Method(实现了AnnotatedElement, GenericDeclaration, Member接口)
   * 得到 方法上的Annotations 然后利用私有方法createValidator(Annotation a)来创建
   * 每一个Annotation 的实现类 Validator 并保存Validator和member
   * @param member
   */
  private void createMemberValidator(Member member) {
    Annotation[] memberAnnotations = ( (AnnotatedElement) member ).getAnnotations();
    for ( int j = 0; j < memberAnnotations.length ; j++ ) {
      Annotation methodAnnotation = memberAnnotations[j];
      Validator propertyValidator = createValidator( methodAnnotation );
      if ( propertyValidator != null ) {
        memberValidators.add( propertyValidator );
        setAccessible( member ); // 设置访问属性
        memberGetters.add( member );
      }
    }
  }

  private static void setAccessible(Member member) {
    if ( !Modifier.isPublic( member.getModifiers() ) ) {
      ( (AccessibleObject) member ).setAccessible( true );
    }
  }

  /**
   * 该方法产生了该Annotation的约束实现类 并初始化该类对应的消息
   */
  private Validator createValidator(Annotation annotation) {
    try {
      //得到ValidatorClass Annotation 
      ValidatorClass validatorClass = annotation.annotationType().getAnnotation( ValidatorClass.class );
      if ( validatorClass == null ) {
        return null;
      }
      // 然后 利用ValidatorClass Annotation 来得到里面的值(即实现该注释的Class),
      //再利用Class 构造一个instance
      Validator beanValidator = validatorClass.value().newInstance();
      beanValidator.initialize( annotation ); // 初始化Annotation中的参数(注意:在自定义约束中该方法有你来实现)
      String messageTemplate = (String) annotation.getClass()
          .getMethod( "message", (Class[]) null )
          .invoke( annotation );  // 取得 constraint descriptor  中的message 的值
      String message = replace( messageTemplate, annotation ); // 初始化取得的模板消息 请参考 replace函数
      messages.put( beanValidator, message ); // 把message 放在map中,以便使用
      return beanValidator; // 返回 产生的Validator
    }
    catch (Exception e) {
      throw new IllegalArgumentException( "could not instantiate ClassValidator", e );
    }
  }

  public boolean hasValidationRules() {
    return beanValidators.size() != 0 || memberValidators.size() != 0;
  }

  /**
   * apply constraints on a bean instance and return all the failures.
   */
  public InvalidValue[] getInvalidValues(T bean) {
    return this.getInvalidValues( bean, new IdentitySet() );
  }

  /**
   * apply constraints on a bean instance and return all the failures.
   */
  protected InvalidValue[] getInvalidValues(T bean, Set<Object> circularityState) {
    if ( circularityState.contains( bean ) ) {  // 该if else 是和Hibernate Core由关的,
      return EMPTY_INVALID_VALUE_ARRAY; //Avoid circularity
    }
    else {
      circularityState.add( bean );
    }

    if ( !beanClass.isInstance( bean ) ) { // 如果beanClass不是该bean的实例,则抛出异常
      throw new IllegalArgumentException( "not an instance of: " + bean.getClass() );
    }

    List<InvalidValue> results = new ArrayList<InvalidValue>();

    for ( int i = 0; i < beanValidators.size() ; i++ ) { // 验证类级别的约束
      Validator validator = beanValidators.get( i );
      if ( !validator.isValid( bean ) ) { //调用isValid方法,如果没有通过则添加到list<InvalidValue>中
                        //如果是自定义约束则isValid方法 由你来实现
        results.add( new InvalidValue( messages.get( validator ), beanClass, null, bean, bean ) );
      }
    }

    for ( int i = 0; i < memberValidators.size() ; i++ ) {//验证方法级别的约束
      Member getter = memberGetters.get( i );
      if ( Hibernate.isPropertyInitialized(bean, getter.getName() ) ) {// ? 检查该属性是否已初始化
        Object value = getMemberValue( bean, getter );//利用反射 取得该属性的值
        Validator validator = memberValidators.get( i ); //取得该约束的验证实现类
        if ( !validator.isValid( value ) ) {//调用isValid方法,如果没有通过则添加到list<InvalidValue>中
          String propertyName = getPropertyName( getter );
          results.add( new InvalidValue( messages.get( validator ), beanClass, propertyName, value, bean ) );
        }
      }
    }

    for ( int i = 0; i < childGetters.size() ; i++ ) {// 处理子类类
      Member getter = childGetters.get( i );
      if ( Hibernate.isPropertyInitialized(bean, getter.getName() ) ) { //检查该属性是否已初始化
        Object value = getMemberValue( bean, getter );
        if ( value != null && Hibernate.isInitialized( value ) ) {
          String propertyName = getPropertyName( getter );
          InvalidValue[] invalidValues = getClassValidator( value )
              .getInvalidValues( value, circularityState );// 通过参数value 得到 Class, 然后由Class作为key          //在childClassValidators map中得到其ClassValidator
                                     //如果不存在 则创建新的 ,然后再调用ClassValidator的getInvalidValues方法
          // 注意在调用getInvalidValues方法时 用到了circularityState 参数, 当调用循环一周时 返回(递归结束)
          for ( InvalidValue invalidValue : invalidValues ) {
            invalidValue.addParentBean( bean, propertyName );
            results.add( invalidValue ); //添加的结果中
          }
        }
      }
    }

    return results.toArray( new InvalidValue[results.size()] ); //返回InvalidValue数组
  }

  /**
   * 通过参数value 得到 Class, 然后由Class作为key 在childClassValidators map中得到其ClassValidator
   * 如果不存在 则创建新的 然后返回
   * @param value
   * @return
   */
  private ClassValidator getClassValidator(Object value) {
    Class clazz = value.getClass();
    ClassValidator validator = childClassValidators.get( clazz );
    if ( validator == null ) { //handles polymorphism
      validator = new ClassValidator( clazz );
    }
    return validator;
  }

  /**
   * Apply constraints of a particular property on a bean instance and return all the failures.
   * Note this is not recursive.
   * 验证单个属性的约束.
   */
  //TODO should it be recursive ?
  public InvalidValue[] getInvalidValues(T bean, String propertyName) {
    List<InvalidValue> results = new ArrayList<InvalidValue>();

    for ( int i = 0; i < memberValidators.size() ; i++ ) {
      Member getter = memberGetters.get( i );
      if ( getPropertyName( getter ).equals( propertyName ) ) {// 验证该属性的约束
        Object value = getMemberValue( bean, getter );
        Validator validator = memberValidators.get( i );
        if ( !validator.isValid( value ) ) {
          results.add( new InvalidValue( messages.get( validator ), beanClass, propertyName, value, bean ) );
        }
      }
    }

    return results.toArray( new InvalidValue[results.size()] );
  }

  /**
   * Apply constraints of a particular property value of a bean type and return all the failures.
   * The InvalidValue objects returns return null for InvalidValue#getBean() and InvalidValue#getRootBean()
   * Note this is not recursive.
   * 验证 value 是否满足当前属性的约束.
   */
  //TODO should it be recursive?
  public InvalidValue[] getPotentialInvalidValues(String propertyName, Object value) {
    List<InvalidValue> results = new ArrayList<InvalidValue>();

    for ( int i = 0; i < memberValidators.size() ; i++ ) {
      Member getter = memberGetters.get( i );
      if ( getPropertyName( getter ).equals( propertyName ) ) {
        Validator validator = memberValidators.get( i );
        if ( !validator.isValid( value ) ) {
          results.add( new InvalidValue( messages.get( validator ), beanClass, propertyName, value, null ) );
        }
      }
    }

    return results.toArray( new InvalidValue[results.size()] );
  }

  private Object getMemberValue(T bean, Member getter) {
    Object value;
    try {
      value = getValue( getter, bean );
    }
    catch (Exception e) {
      throw new IllegalStateException( "Could not get property value", e );
    }
    return value;
  }

  private Object getValue(Member member, T bean) throws IllegalAccessException, InvocationTargetException {
    if ( member instanceof Field ) {
      return ( (Field) member ).get( bean );
    }
    else if ( member instanceof Method ) {
      return ( (Method) member ).invoke( bean );
    }
    else {
      throw new AssertionFailure( "Unexpected member: " + member.getClass().getName() );
    }
  }

  public String getPropertyName(Member member) {
    //Do no try to cache the result in a map, it's actually much slower (2.x time)
    String propertyName;
    if ( member instanceof Field ) {
      propertyName = member.getName();
    }
    else if ( member instanceof Method ) {
      propertyName = member.getName();
      if ( propertyName.startsWith( "is" ) ) {
        propertyName = Introspector.decapitalize( propertyName.substring( 2 ) );
      }
      else if ( propertyName.startsWith( "get" ) ) {
        propertyName = Introspector.decapitalize( propertyName.substring( 3 ) );
      }
      //do nothing for non getter method, in case someone want to validate a PO Method
    }
    else {
      throw new AssertionFailure( "Unexpected member: " + member.getClass().getName() );
    }
    return propertyName;
  }

  private String replace(String message, Annotation parameters) {
    StringTokenizer tokens = new StringTokenizer( message, "{}", true );
    StringBuilder buf = new StringBuilder( 30 );
    boolean escaped = false;
    while ( tokens.hasMoreTokens() ) {
      String token = tokens.nextToken();
      if ( "{".equals( token ) ) {
        escaped = true;
      }
      else if ( "}".equals( token ) ) {
        escaped = false;
      }
      else if ( !escaped ) {
        buf.append( token );
      }
      else {
        Method member;
        try {
          member = parameters.getClass().getMethod( token, (Class[]) null );
        }
        catch (NoSuchMethodException nsfme) {
          member = null;
        }
        if ( member != null ) {
          try {
            buf.append( member.invoke( parameters ) );
          }
          catch (Exception e) {
            throw new IllegalArgumentException( "could not render message", e );
          }
        }
        else if ( messageBundle != null ) {
          String string = messageBundle.getString( token );
          if ( string != null ) buf.append( replace( string, parameters ) );
        }
      }
    }
    return buf.toString();
  }

  /**
   * apply the registred constraints rules on the hibernate metadata (to be applied on DB schema...)
   *该方法是与实体类绑定的 不推荐使用 有兴趣的读者可以自己研究一下
   * @param persistentClass hibernate metadata
   */
  public void apply(PersistentClass persistentClass) {  
   //源代码省略
  }

  /**
   * 断言该bean 是否符合所有约束. 负责抛出异常
   * @param bean
   */
  public void assertValid(T bean) {
    InvalidValue[] values = getInvalidValues( bean );
    if ( values.length > 0 ) {
      throw new InvalidStateException( values );
    }
  }

  /**
   * 该方法应该是序列化ResourceBundle的 为private方法 但并没有用到, 不知道为什么 可能以后会有用
   * @param oos
   * @throws IOException
   */
  private void writeObject(ObjectOutputStream oos) throws IOException {
    ResourceBundle rb = messageBundle;
    if ( rb != null && ! ( rb instanceof Serializable ) ) {
      messageBundle = null;
      if ( ! defaultResourceBundle )
        log.warn( "Serializing a ClassValidator with a not serializable ResourceBundle: ResourceBundle ignored" );
    }
    oos.defaultWriteObject();
    oos.writeObject( messageBundle );
    messageBundle = rb;
  }

  /**
   * 该方法应该是读取序列化的ResourceBundle的 为private方法 但并没有用到,不知道为什么 可能以后会有用
   * @param ois
   * @throws IOException
   * @throws ClassNotFoundException
   */
  private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
    ois.defaultReadObject();
    ResourceBundle rb = (ResourceBundle) ois.readObject();
    if (rb == null) rb = getDefaultResourceBundle();
    initValidator( beanClass, new HashMap<Class, ClassValidator>(), rb );
  }
} 

 ClassValidator<Person> classValidator = new ClassValidator<Person> (Person.class);
 InvalidValue[] validMessages = classValidator.getInvalidValues(p);

首先，请到http://www.andykhan.com/jexcelapi/index.html下载java excel api，主页上同时有比较详细的介绍。最新版本为2.4.3，同时也可以到：http://www.andykhan.com/jexcelapi/jexcelapi_2_4_3.tar.gz下载到该最新版的API，由于该项目是开源的，所以下载的文件中已经包含了源代码，同样的，文件中也有javadoc，大家在开发中可以参考javadoc。

下载完毕后，我们需要把文件中的jxl.jar加入到你的开发classpath中。
下图是现在要生产的excel截图：
http://blog.csdn.net/beming/gallery/image/3437.aspx

代码如下：

   File excel = new File("d:/aming.xls");
   if(!excel.exists()){
    excel.createNewFile();
   }   
   WritableWorkbook wwb = Workbook.createWorkbook(excel);
   WritableSheet ws = wwb.createSheet("testexcel",0);
   Label lable = null;
   
   //对中文的支持非常好
   lable = new Label(0,0,"我的中国心");
   ws.addCell(lable);
   
   //可以定义模板格式化你的cell
   WritableFont wf = new WritableFont(WritableFont.ARIAL,10,WritableFont.NO_BOLD,false,UnderlineStyle.NO_UNDERLINE, Colour.BLACK);
   WritableCellFormat wcf = new WritableCellFormat(wf);
   wcf.setBackground(Colour.WHITE);
   lable = new Label(0,1,"fdsl",wcf);
   ws.addCell(lable);
   
   wf = new WritableFont(WritableFont.TIMES,18,WritableFont.BOLD,true);
   wcf = new WritableCellFormat(wf);
   lable = new Label(0,2,"aming",wcf);
   ws.addCell(lable);
   
   //cell的类型同样可以定义为数字类型
   Number nb = new Number(0,3,21.4321321);
   ws.addCell(nb);
   
   //支持格式化你的数字串
   NumberFormat nf = new NumberFormat("#.###");
   wcf = new WritableCellFormat(nf);
   nb = new Number(0,4,21.43254354354354,wcf);
   ws.addCell(nb);

   //cell的类型可以为boolean类型
   Boolean bl = new Boolean(0,5,true);
   ws.addCell(bl);

   //cell的类型同样可以为日期，时间
   DateTime dt = new DateTime(0,6,new Date());
   ws.addCell(dt);

   //并且可以很好格式化你的日期格式
   DateFormat df = new DateFormat("MM dd yyyy hh:mm:ss");
   wcf = new WritableCellFormat(df);
   dt = new DateTime(0,7,new Date(),wcf);
   ws.addCell(dt);
   
   //开始写文件了
   wwb.write();
   wwb.close();

　　在企业的信息系统中，报表处理一直占比较重要的作用，本文将介绍一种生成PDF报表的Java组件--iText。通过在服务器端使用Jsp或JavaBean生成PDF报表，客户端采用超级连接显示或下载得到生成的报表，这样就很好的解决了B/S系统的报表处理问题。

　　二、iText简介

　　iText是著名的开放源码的站点sourceforge一个项目，是用于生成PDF文档的一个java类库。通过iText不仅可以生成PDF或rtf的文档，而且可以将XML、Html文件转化为PDF文件。

　　iText的安装非常方便，在http://www.lowagie.com/iText/download.html - download 网站上下载iText.jar文件后，只需要在系统的CLASSPATH中加入iText.jar的路径，在程序中就可以使用iText类库了。

　　三、建立第一个PDF文档

　　用iText生成PDF文档需要5个步骤：

　　①建立com.lowagie.text.Document对象的实例。

Document document = new Document();

　　②建立一个书写器(Writer)与document对象关联，通过书写器(Writer)可以将文档写入到磁盘中。

PDFWriter.getInstance(document, new FileOutputStream("Helloworld.PDF"));

　　③打开文档。

document.open();

　　④向文档中添加内容。

document.add(new Paragraph("Hello World"));

　　⑤关闭文档。

document.close();

　　通过上面的5个步骤，就能产生一个Helloworld.PDF的文件，文件内容为"Hello World"。

　　建立com.lowagie.text.Document对象的实例

　　com.lowagie.text.Document对象的构建函数有三个，分别是：

public Document();
public Document(Rectangle pageSize);
public Document(Rectangle pageSize,
int marginLeft,
int marginRight,
int marginTop,
int marginBottom);

　　构建函数的参数pageSize是文档页面的大小，对于第一个构建函数，页面的大小为A4，同Document(PageSize.A4)的效果一样；对于第三个构建函数，参数marginLeft、marginRight、marginTop、marginBottom分别为左、右、上、下的页边距。

　　通过参数pageSize可以设定页面大小、面背景色、以及页面横向/纵向等属性。iText定义了A0-A10、AL、LETTER、HALFLETTER、_11x17、LEDGER、NOTE、B0-B5、ARCH_A-ARCH_E、FLSA 和FLSE等纸张类型，也可以通过Rectangle pageSize = new Rectangle(144, 720);自定义纸张。通过Rectangle方法rotate()可以将页面设置成横向。

　　书写器（Writer）对象

　　一旦文档(document)对象建立好之后，需要建立一个或多个书写器(Writer)对象与之关联。通过书写器(Writer)对象可以将具体文档存盘成需要的格式，如com.lowagie.text.PDF.PDFWriter可以将文档存成PDF文件，com.lowagie.text.html.HtmlWriter可以将文档存成html文件。

　　设定文档属性

　　在文档打开之前，可以设定文档的标题、主题、作者、关键字、装订方式、创建者、生产者、创建日期等属性，调用的方法分别是：

public boolean addTitle(String title)
public boolean addSubject(String subject)
public boolean addKeywords(String keywords)
public boolean addAuthor(String author)
public boolean addCreator(String creator)
public boolean addProducer()
public boolean addCreationDate()
public boolean addHeader(String name, String content)

　　其中方法addHeader对于PDF文档无效，addHeader仅对html文档有效，用于添加文档的头信息。
当新的页面产生之前，可以设定页面的大小、书签、脚注（HeaderFooter）等信息，调用的方法是：

public boolean setPageSize(Rectangle pageSize)
public boolean add(Watermark watermark)
public void removeWatermark()
public void setHeader(HeaderFooter header)
public void resetHeader()
public void setFooter(HeaderFooter footer)
public void resetFooter()
public void resetPageCount()
public void setPageCount(int pageN)  

　　如果要设定第一页的页面属性，这些方法必须在文档打开之前调用。

　　对于PDF文档，iText还提供了文档的显示属性，通过调用书写器的setViewerPreferences方法可以控制文档打开时Acrobat Reader的显示属性，如是否单页显示、是否全屏显示、是否隐藏状态条等属性。

　　另外，iText也提供了对PDF文件的安全保护，通过书写器（Writer）的setEncryption方法，可以设定文档的用户口令、只读、可打印等属性。

　　添加文档内容

　　所有向文档添加的内容都是以对象为单位的，如Phrase、Paragraph、Table、Graphic对象等。比较常用的是段落(Paragraph)对象，用于向文档中添加一段文字。

四、文本处理

　　iText中用文本块(Chunk)、短语(Phrase)和段落(paragraph)处理文本。
文本块(Chunk)是处理文本的最小单位，有一串带格式（包括字体、颜色、大小）的字符串组成。如以下代码就是产生一个字体为HELVETICA、大小为10、带下划线的字符串：

Chunk chunk1 = new Chunk("This text is underlined", FontFactory.getFont(FontFactory.HELVETICA, 12, Font.UNDERLINE));  

　　短语(Phrase)由一个或多个文本块(Chunk)组成，短语(Phrase)也可以设定字体，但对于其中以设定过字体的文本块(Chunk)无效。通过短语(Phrase)成员函数add可以将一个文本块(Chunk)加到短语(Phrase)中，如：phrase6.add(chunk);

　　段落(paragraph)由一个或多个文本块(Chunk)或短语(Phrase)组成，相当于WORD文档中的段落概念，同样可以设定段落的字体大小、颜色等属性。另外也可以设定段落的首行缩进、对齐方式（左对齐、右对齐、居中对齐）。通过函数setAlignment可以设定段落的对齐方式，setAlignment的参数1为居中对齐、2为右对齐、3为左对齐，默认为左对齐。

　　五、表格处理

　　iText中处理表格的类为：com.lowagie.text.Table和com.lowagie.text.PDF.PDFPTable，对于比较简单的表格处理可以用com.lowagie.text.Table，但是如果要处理复杂的表格，这就需要com.lowagie.text.PDF.PDFPTable进行处理。这里就类com.lowagie.text.Table进行说明。

　　类com.lowagie.text.Table的构造函数有三个：

　　　①Table (int columns)
　　　②Table(int columns, int rows)
　　　③Table(Properties attributes)

　　参数columns、rows、attributes分别为表格的列数、行数、表格属性。创建表格时必须指定表格的列数，而对于行数可以不用指定。

　　建立表格之后，可以设定表格的属性，如：边框宽度、边框颜色、衬距（padding space 即单元格之间的间距）大小等属性。下面通过一个简单的例子说明如何使用表格，代码如下：

1:Table table = new Table(3);
2:table.setBorderWidth(1);
3:table.setBorderColor(new Color(0, 0, 255));
4:table.setPadding(5);
5:table.setSpacing(5);
6:Cell cell = new Cell("header");
7:cell.setHeader(true);
8:cell.setColspan(3);
9:table.addCell(cell);
10:table.endHeaders();
11:cell = new Cell("example cell with colspan 1 and rowspan 2");
12:cell.setRowspan(2);
13:cell.setBorderColor(new Color(255, 0, 0));
14:table.addCell(cell);
15:table.addCell("1.1");
16:table.addCell("2.1");
17:table.addCell("1.2");
18:table.addCell("2.2");
19:table.addCell("cell test1");
20:cell = new Cell("big cell");
21:cell.setRowspan(2);
22:cell.setColspan(2);
23:table.addCell(cell);
24:table.addCell("cell test2");

　　运行结果如下：

header  
example cell with colspan 1 and rowspan 2  1.1 2.1  
1.2 2.2  
cell test1 big cell  
cell test2  

　　代码1-5行用于新建一个表格，如代码所示，建立了一个列数为3的表格，并将边框宽度设为1，颜色为蓝色，衬距为5。

　　代码6-10行用于设定表格的表头，第7行cell.setHeader(true);是将该单元格作为表头信息显示；第8行cell.setColspan(3);指定了该单元格占3列；为表格添加表头信息时，要注意的是一旦表头信息添加完了之后，必须调用endHeaders()方法，如第10行，否则当表格跨页后，表头信息不会再显示。

　　代码11-14行是向表格中添加一个宽度占一列，长度占二行的单元格。

　　往表格中添加单元格(cell)时，按自左向右、从上而下的次序添加。如执行完11行代码后，表格的右下方出现2行2列的空白，这是再往表格添加单元格时，先填满这个空白，然后再另起一行，15-24行代码说明了这种添加顺序。

　　六、图像处理

　　iText中处理表格的类为com.lowagie.text.Image，目前iText支持的图像格式有：GIF, Jpeg, PNG, wmf等格式，对于不同的图像格式，iText用同样的构造函数自动识别图像格式。通过下面的代码分别获得gif、jpg、png图像的实例。

Image gif = Image.getInstance("vonnegut.gif");
Image jpeg = Image.getInstance("myKids.jpg");
Image png = Image.getInstance("hitchcock.png");

　　图像的位置

　　图像的位置主要是指图像在文档中的对齐方式、图像和文本的位置关系。IText中通过函数public void setAlignment(int alignment)进行处理，参数alignment为Image.RIGHT、Image.MIDDLE、Image.LEFT分别指右对齐、居中、左对齐；当参数alignment为Image.TEXTWRAP、Image.UNDERLYING分别指文字绕图形显示、图形作为文字的背景显示。这两种参数可以结合以达到预期的效果，如setAlignment(Image.RIGHT|Image.TEXTWRAP)显示的效果为图像右对齐，文字围绕图像显示。

　　图像的尺寸和旋转

　　如果图像在文档中不按原尺寸显示，可以通过下面的函数进行设定：

public void scaleAbsolute(int newWidth, int newHeight)
public void scalePercent(int percent)
public void scalePercent(int percentX, int percentY)

　　函数public void scaleAbsolute(int newWidth, int newHeight)直接设定显示尺寸；函数public void scalePercent(int percent)设定显示比例，如scalePercent(50)表示显示的大小为原尺寸的50%；而函数scalePercent(int percentX, int percentY)则图像高宽的显示比例。

　　如果图像需要旋转一定角度之后在文档中显示，可以通过函数public void setRotation(double r)设定，参数r为弧度，如果旋转角度为30度，则参数r= Math.PI / 6。

　　七、中文处理

　　默认的iText字体设置不支持中文字体，需要下载远东字体包iTextAsian.jar，否则不能往PDF文档中输出中文字体。通过下面的代码就可以在文档中使用中文了：

BaseFont bfChinese = BaseFont.createFont("STSong-Light", "UniGB-UCS2-H", BaseFont.NOT_EMBEDDED);
com.lowagie.text.Font FontChinese = new com.lowagie.text.Font(bfChinese, 12, com.lowagie.text.Font.NORMAL);
Paragraph pragraph=new Paragraph("你好", FontChinese);  

　　八、后记

　　iText还有很多高级的功能，这里就不一一介绍了，具体开发时可参考发布的文档。总的来说，iText是一套java环境下不错的制作PDF的组件。因为iText支持jsp/javabean下的开发，这使得B/S应用中的报表问题能得到很好的解决。由于iText毕竟不是专门为制作报表设计，所有报表中的内容、格式都需要通过写代码实现，相对于那些专业的支持可视化设计的报表软件来说，编程的工作量就有一定程度的增加。