Elliotte Rusty Harold: XML documents must be well-formed. There are, depending on how you count, anywhere from a hundred to several thousand different rules. These "well-formedness" rules are the minimum requirements for an XML document. The rules cover things like what characters are allowed in element names: The letter 'a' is OK. The letter omega is OK. The asterisk character is not OK. White space is not OK. The rules say that every start-tag has to have a matching end-tag. Elements can nest, but they cannot overlap. Processing instructions have the form <, ?, a target, white space, the data, ?, and a >. Comments cannot contain a double hyphen. There are many such rules governing well-formedness of XML documents.

Validity talks about which elements and attributes are allowed where. Well-formedness only talks about the structure of any XML document, irrespective of what the names are. Validity says, we're only going to allow these elements with these names in these positions. Validity is not required. Well-formedness is.

1 从Excel文件读取数据表

Java Excel API既可以从本地文件系统的一个文件(.xls)，也可以从输入流中读取Excel数据表。读取Excel数据表的第一步是创建Workbook(术语：工作薄)，下面的代码片段举例说明了应该如何操作：(完整代码见ExcelReading.java)

import java.io.*;
import jxl.*;
… … … …
try
{
//构建Workbook对象, 只读Workbook对象
	//直接从本地文件创建Workbook
//从输入流创建Workbook
    InputStream is = new FileInputStream(sourcefile);
    jxl.Workbook rwb = Workbook.getWorkbook(is);
}
catch (Exception e)
{
	e.printStackTrace();
}

一旦创建了Workbook，我们就可以通过它来访问Excel Sheet(术语：工作表)。参考下面的代码片段：

//获取第一张Sheet表
Sheet rs = rwb.getSheet(0);

我们既可能通过Sheet的名称来访问它，也可以通过下标来访问它。如果通过下标来访问的话，要注意的一点是下标从0开始，就像数组一样。

一旦得到了Sheet，我们就可以通过它来访问Excel Cell(术语：单元格)。参考下面的代码片段：

//获取第一行，第一列的值
Cell c00 = rs.getCell(0, 0);
String strc00 = c00.getContents();

//获取第一行，第二列的值
Cell c10 = rs.getCell(1, 0);
String strc10 = c10.getContents();

//获取第二行，第二列的值
Cell c11 = rs.getCell(1, 1);
String strc11 = c11.getContents();

System.out.println("Cell(0, 0)" + " value : " + strc00 + "; type : " + c00.getType());
System.out.println("Cell(1, 0)" + " value : " + strc10 + "; type : " + c10.getType());
System.out.println("Cell(1, 1)" + " value : " + strc11 + "; type : " + c11.getType());

如果仅仅是取得Cell的值，我们可以方便地通过getContents()方法，它可以将任何类型的Cell值都作为一个字符串返回。示例代码中Cell(0, 0)是文本型，Cell(1, 0)是数字型，Cell(1,1)是日期型，通过getContents()，三种类型的返回值都是字符型。

如果有需要知道Cell内容的确切类型，API也提供了一系列的方法。参考下面的代码片段：

String strc00 = null;
double strc10 = 0.00;
Date strc11 = null;

Cell c00 = rs.getCell(0, 0);
Cell c10 = rs.getCell(1, 0);
Cell c11 = rs.getCell(1, 1);

if(c00.getType() == CellType.LABEL)
{
LabelCell labelc00 = (LabelCell)c00;
strc00 = labelc00.getString();
}
if(c10.getType() == CellType.NUMBER)
{
	NmberCell numc10 = (NumberCell)c10;
strc10 = numc10.getValue();
}
if(c11.getType() == CellType.DATE)
{
DateCell datec11 = (DateCell)c11;
strc11 = datec11.getDate();
}

System.out.println("Cell(0, 0)" + " value : " + strc00 + "; type : " + c00.getType());
System.out.println("Cell(1, 0)" + " value : " + strc10 + "; type : " + c10.getType());
System.out.println("Cell(1, 1)" + " value : " + strc11 + "; type : " + c11.getType());

在得到Cell对象后，通过getType()方法可以获得该单元格的类型，然后与API提供的基本类型相匹配，强制转换成相应的类型，最后调用相 应的取值方法getXXX()，就可以得到确定类型的值。API提供了以下基本类型，与Excel的数据格式相对应，如下图所示：

每种类型的具体意义，请参见Java Excel API Document。

当你完成对Excel电子表格数据的处理后，一定要使用close()方法来关闭先前创建的对象，以释放读取数据表的过程中所占用的内存空间，在读取大量数据时显得尤为重要。参考如下代码片段：

//操作完成时，关闭对象，释放占用的内存空间
rwb.close();

Java Excel API提供了许多访问Excel数据表的方法，在这里我只简要地介绍几个常用的方法，其它的方法请参考附录中的Java Excel API Document。

Workbook类提供的方法

1. int getNumberOfSheets()
获得工作薄（Workbook）中工作表（Sheet）的个数，示例：

jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile));
int sheets = rwb.getNumberOfSheets();

2. Sheet[] getSheets()
返回工作薄（Workbook）中工作表（Sheet）对象数组，示例：

jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile));
Sheet[] sheets = rwb.getSheets();

3. String getVersion()
返回正在使用的API的版本号，好像是没什么太大的作用。

jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile));
String apiVersion = rwb.getVersion();

Sheet接口提供的方法

1) String getName()
获取Sheet的名称，示例：

jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile));
jxl.Sheet rs = rwb.getSheet(0);
String sheetName = rs.getName();

2) int getColumns()
获取Sheet表中所包含的总列数，示例：

jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile));
jxl.Sheet rs = rwb.getSheet(0);
int rsColumns = rs.getColumns();

3) Cell[] getColumn(int column)
获取某一列的所有单元格，返回的是单元格对象数组，示例：

jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile));
jxl.Sheet rs = rwb.getSheet(0);
Cell[] cell = rs.getColumn(0);

4) int getRows()
获取Sheet表中所包含的总行数，示例：

jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile));
jxl.Sheet rs = rwb.getSheet(0);
int rsRows = rs.getRows();

5) Cell[] getRow(int row)
获取某一行的所有单元格，返回的是单元格对象数组，示例子：

jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile));
jxl.Sheet rs = rwb.getSheet(0);
Cell[] cell = rs.getRow(0);

6) Cell getCell(int column, int row)
获取指定单元格的对象引用，需要注意的是它的两个参数，第一个是列数，第二个是行数，这与通常的行、列组合有些不同。

jxl.Workbook rwb = jxl.Workbook.getWorkbook(new File(sourcefile));
jxl.Sheet rs = rwb.getSheet(0);
Cell cell = rs.getCell(0, 0);

2 生成新的Excel工作薄

下面的代码主要是向大家介绍如何生成简单的Excel工作表，在这里单元格的内容是不带任何修饰的(如：字体，颜色等等)，所有的内容都作为字符串写入。(完整代码见ExcelWriting.java)

与读取Excel工作表相似，首先要使用Workbook类的工厂方法创建一个可写入的工作薄(Workbook)对象，这里要注意的是，只能通过 API提供的工厂方法来创建Workbook，而不能使用WritableWorkbook的构造函数，因为类WritableWorkbook的构造函 数为protected类型。示例代码片段如下：

import java.io.*;
import jxl.*;
import jxl.write.*;
… … … …
try
{
//构建Workbook对象, 只读Workbook对象
//Method 1：创建可写入的Excel工作薄
    jxl.write.WritableWorkbook wwb = Workbook.createWorkbook(new File(targetfile));

//Method 2：将WritableWorkbook直接写入到输出流
/*
    OutputStream os = new FileOutputStream(targetfile);
    jxl.write.WritableWorkbook wwb = Workbook.createWorkbook(os);
*/
}
catch (Exception e)
{
	e.printStackTrace();
}

API提供了两种方式来处理可写入的输出流，一种是直接生成本地文件，如果文件名不带全路径的话，缺省的文件会定位在当前目录，如果文件名带有全路 径的话，则生成的Excel文件则会定位在相应的目录；另外一种是将Excel对象直接写入到输出流，例如：用户通过浏览器来访问Web服务器，如果 HTTP头设置正确的话，浏览器自动调用客户端的Excel应用程序，来显示动态生成的Excel电子表格。

接下来就是要创建工作表，创建工作表的方法与创建工作薄的方法几乎一样，同样是通过工厂模式方法获得相应的对象，该方法需要两个参数，一个是工作表的名称，另一个是工作表在工作薄中的位置，参考下面的代码片段：

//创建Excel工作表
jxl.write.WritableSheet ws = wwb.createSheet("Test Sheet 1", 0);

"这锅也支好了，材料也准备齐全了，可以开始下锅了！"，现在要做的只是实例化API所提供的Excel基本数据类型，并将它们添加到工作表中就可以了，参考下面的代码片段：

//1.添加Label对象
jxl.write.Label labelC = new jxl.write.Label(0, 0, "This is a Label cell");
ws.addCell(labelC);

//添加带有字型Formatting的对象
jxl.write.WritableFont wf = new jxl.write.WritableFont(WritableFont.TIMES, 18, WritableFont.BOLD, true);
jxl.write.WritableCellFormat wcfF = new jxl.write.WritableCellFormat(wf);
jxl.write.Label labelCF = new jxl.write.Label(1, 0, "This is a Label Cell", wcfF);
ws.addCell(labelCF);

//添加带有字体颜色Formatting的对象
jxl.write.WritableFont wfc = new jxl.write.WritableFont(WritableFont.ARIAL, 10, WritableFont.NO_BOLD, false,
UnderlineStyle.NO_UNDERLINE, jxl.format.Colour.RED);
jxl.write.WritableCellFormat wcfFC = new jxl.write.WritableCellFormat(wfc);
jxl.write.Label labelCFC = new jxl.write.Label(1, 0, "This is a Label Cell", wcfFC);
ws.addCell(labelCF);

//2.添加Number对象
jxl.write.Number labelN = new jxl.write.Number(0, 1, 3.1415926);
ws.addCell(labelN);

//添加带有formatting的Number对象
jxl.write.NumberFormat nf = new jxl.write.NumberFormat("#.##");
jxl.write.WritableCellFormat wcfN = new jxl.write.WritableCellFormat(nf);
jxl.write.Number labelNF = new jxl.write.Number(1, 1, 3.1415926, wcfN);
ws.addCell(labelNF);

//3.添加Boolean对象
jxl.write.Boolean labelB = new jxl.write.Boolean(0, 2, false);
ws.addCell(labelB);

//4.添加DateTime对象
jxl.write.DateTime labelDT = new jxl.write.DateTime(0, 3, new java.util.Date());
ws.addCell(labelDT);

//添加带有formatting的DateFormat对象
jxl.write.DateFormat df = new jxl.write.DateFormat("dd MM yyyy hh:mm:ss");
jxl.write.WritableCellFormat wcfDF = new jxl.write.WritableCellFormat(df);
jxl.write.DateTime labelDTF = new jxl.write.DateTime(1, 3, new java.util.Date(), wcfDF);
ws.addCell(labelDTF);

这里有两点大家要引起大家的注意。第一点，在构造单元格时，单元格在工作表中的位置就已经确定了。一旦创建后，单元格的位置是不能够变更的，尽管单元格的内容是可以改变的。第二点，单元格的定位是按照下面这样的规律(column, row)，而且下标都是从0开始，例如，A1被存储在(0, 0)，B1被存储在(1, 0)。

最后，不要忘记关闭打开的Excel工作薄对象，以释放占用的内存，参见下面的代码片段：

//写入Exel工作表
wwb.write();

//关闭Excel工作薄对象
wwb.close();

这可能与读取Excel文件的操作有少少不同，在关闭Excel对象之前，你必须要先调用write()方法，因为先前的操作都是存储在缓存中的，所以要通过该方法将操作的内容保存在文件中。如果你先关闭了Excel对象，那么只能得到一张空的工作薄了。

3 拷贝、更新Excel工作薄
接下来简要介绍一下如何更新一个已经存在的工作薄，主要是下面二步操作，第一步是构造只读的Excel工作薄，第二步是利用已经创建的Excel工作薄创建新的可写入的Excel工作薄，参考下面的代码片段：(完整代码见ExcelModifying.java)

//创建只读的Excel工作薄的对象
jxl.Workbook rw = jxl.Workbook.getWorkbook(new File(sourcefile));

//创建可写入的Excel工作薄对象
jxl.write.WritableWorkbook  wwb = Workbook.createWorkbook(new File(targetfile), rw);
            
//读取第一张工作表
jxl.write.WritableSheet ws = wwb.getSheet(0);

//获得第一个单元格对象
jxl.write.WritableCell wc = ws.getWritableCell(0, 0);
            
//判断单元格的类型, 做出相应的转化
if(wc.getType() == CellType.LABEL)
{
Label l = (Label)wc;
    l.setString("The value has been modified.");
}

//写入Excel对象
wwb.write();

//关闭可写入的Excel对象
wwb.close();

//关闭只读的Excel对象
rw.close();

之所以使用这种方式构建Excel对象，完全是因为效率的原因，因为上面的示例才是API的主要应用。为了提高性能，在读取工作表时，与数据相关的 一些输出信息，所有的格式信息，如：字体、颜色等等，是不被处理的，因为我们的目的是获得行数据的值，既使没有了修饰，也不会对行数据的值产生什么影响。 唯一的不利之处就是，在内存中会同时保存两个同样的工作表，这样当工作表体积比较大时，会占用相当大的内存，但现在好像内存的大小并不是什么关键因素了。

一旦获得了可写入的工作表对象，我们就可以对单元格对象进行更新的操作了，在这里我们不必调用API提供的add()方法，因为单元格已经于工作表当中，所以我们只需要调用相应的setXXX()方法，就可以完成更新的操作了。

尽单元格原有的格式化修饰是不能去掉的，我们还是可以将新的单元格修饰加上去，以使单元格的内容以不同的形式表现。

新生成的工作表对象是可写入的，我们除了更新原有的单元格外，还可以添加新的单元格到工作表中，这与示例2的操作是完全一样的。

最后，不要忘记调用write()方法，将更新的内容写入到文件中，然后关闭工作薄对象，这里有两个工作薄对象要关闭，一个是只读的，另外一个是可写入的。

用例图描述了系统的外部接口、系统与参与者的交互行为；类图则描述系统的运行机制与内部协作关系。

分析类图的步骤：

一、识别类及其属性

从用例文档中抽取名词，分析这些名词，从中识别出哪些名词是类、哪些名词是类的属性。

分析中需要注意甄别：去除冗余的同义词；去除系统责任之外的名次；明晰模糊名词；排除行为性名词。

二、审查属性

（1）属性要在系统责任之内

（2）某一个类的属性应该只描述这个类的对象的特征

（3）同一个类的属性之间不能出现交叠

（4）对于具有复杂结构的属性可考虑建立新的类，再与原类形成关联

三、确定类之间的关系

1. 泛化

类之间的关系包括泛化(——|>)、关联(——)和依赖(------à)三种。

泛化指的就是继承关系，它是从父类（超类）的角度来讲的。

泛化的特征：

（1）is-a原则：子类是一种超类。所有子类都必须是超类的成员。

（2）100%原则：超类的定义（包括方法和属性）都不必须100%符合与所有子类。

泛化的缺点：

（1）超类的改变会影响到子类；（2）多重继承会引起命名的冲突。

怎样识别泛化？

（1）根据领域知识：如，生物>动物>哺乳动物>猫科动物>虎

（2）自上而下

含义：现在已经定义了一个类，分析发现这个类的对象有的具备一部分属性，而有些对象又具备另一些属性而没有这部分属性。这时可分解只属于部分对象的属性和操作形成子类。自上而下就是指由父类分解得到子类。

（3）自下而上

含义：与自上而下相反，自下而上指从子类中提取共有的属性和操作形成父类。

（4）考虑领域范围内的复用

如现钞取款机类，为了方便复用，可从中抽取出取款机类，再让现钞取款机类继承取款机类。

审查泛化

（1）是否同处一个领域

例如，温度、质量、高度、压力等量都由实数表示，但是不能把它们设计成实数的子类。

这是一种典型的泛化误用，“见人就叫老爸”！这样的后果：两个领域的类高度耦合，父类的子类无数，子类里的属性和操作无数，隐藏着巨大的危险；如果需要再用另外的操作时，还得再认一个老爸。

（2）子类之间的差异是否可以超类的属性值的不同来加以区别

这可以避免定义过多的子类而是问题复杂化。例如，人作为父类，再定义了中国人、美国人，其实这种差别可以通过在人这个类里添加一个国籍属性就可以实现了。

（3）如果子类没有自己特有的属性和操作，则取消这个子类的定义（子类上移）；如果超类只有一个子类，则取消掉超类（超类下移）。

2. 类之间的关联

关联的含义：通过属性来表示一个对象对另一个对象的静态依赖关系。

首先，关联是对象间的；另外，关联是一种静态的关系，而不是通过操作。

关联的三种表现形式：

连接：—— 最弱的关联，表示两个类的对象之间有导航关系，即。

聚合：A◇——B 表示对象A包含一个对象B。

组合：◆—— 强语义耦合，如果整体消失则部分也消失。

聚合与组合比较：

（还没有找到合适的例子来解释）

（1）作为部分的对象的属性有多少。比如汽车，单独定义一个轮胎类，汽车◇——轮胎。这里轮胎类里的属性过少，反而使设计不够清晰。应把轮胎合并到汽车类中。

1. 读
读XML有多种方法．最基本的方法如下：
<1>用SAXBuilder类构造一个实例，并创建一个文件：
// Build the document with SAX and Xerces, no validation
SAXBuilder builder = new SAXBuilder();
// Create the document
Document doc = builder.build(new File("d:\\data.xml"));
<2>调用Element类中的众多方法获取信息：
一下是在JSP中递归获取XML文件中的元素的基本信息的函数：
public void printChildren(Element parentElement,JspWriter out) throws java.io.IOException
{
    List children = parentElement.getChildren();
 if(children==null || children.size()==0)
  return;
 for(int i=0 ; i<children.size(); i++)
 {
  Element aChild = (Element)children.get(i);
  out.print(aChild.getName()+":");
  out.print(aChild.getText()+"<br>");
  printChildren(aChild,out);
 }
}
上例用到了getChildren()，getName()，getText()三个方法。更多的方法参见doc文档。

2. 写
<1> 创建文档
Document document=new Document(new Element("name of the root Element"));//调用的是new Document(Element rootElement)的构造函数。
说明:
Document类：Document defines behavior for an XML Document，定义了文件级的各种操作。
Element类：Attribute defines behavior for an XML attribute。

<2>逐个逐层写入element
Element chileElement=new Element("name of a child Element");  //创建元素 生成JDOM树
document.getRootElement().addContent(chileElement);
说明：
这个过程主要调用了Element类的addContent(Element anElement)方法。

<3>输出成XML文件
XMLOutputter outp = new XMLOutputter();
outp.output(document, new FileOutputStream("d:\\data.xml")); //输出XML文档
说明：
这种方法得到的XML的格式很不好看，要得到层次明显的XML，可采用如下方法：
a. XMLOutputter outp = new XMLOutputter(Format.getPrettyFormat()); //利用Format类

b. XMLOutputter outputter = new XMLOutputter("", false);//第一个参数代表缩进方式，第二个参数代表是否换行。

c. XMLOutputter outp = new XMLOutputter("",true,"GB2312");//支持中文的带换行和缩进的格式
outp.setTextTrim(true);
outp.output(doc, System.out);

附：读写XML的例程：
1. 读：jdomreadxml.jsp
<%@page contentType="text/html;charset=GBK"%>
<%@page import="java.util.List,java.sql.*,java.io.*,org.jdom.*,org.jdom.output.*,org.jdom.input.*"%>
<%!
public void printChildren(Element parentElement,JspWriter out) throws java.io.IOException
{
    List children = parentElement.getChildren();
 if(children==null || children.size()==0)
  return;
 for(int i=0 ; i<children.size(); i++)
 {
  Element aChild = (Element)children.get(i);
  out.print(aChild.getName()+":");
  out.print(aChild.getText()+"<br>");
  printChildren(aChild,out);
 }
}
%>
<HTML>
<HEAD>
<TITLE>用JDOM实现数据库到XML的转换</TITLE>
</HEAD>
<BODY>
<%
// Build the document with SAX and Xerces, no validation
SAXBuilder builder = new SAXBuilder();
// Create the document
Document doc = builder.build(new File("d:\\data.xml"));
Element rootElement = doc.getRootElement();
out.print("Elements go here:");
out.print("<br>");
printChildren(rootElement,out);
%>
</BODY>
</HTML>

2. 写：（从Access数据库中获取字段并写入）
jdomdbtoxml.jsp
<%@page contentType="text/html;charset=GBK"%>
<%@page import="java.sql.*,java.io.*,org.jdom.*,org.jdom.output.*"%>
<HTML>
<HEAD>
<TITLE>用JDOM实现数据库到XML的转换</TITLE>
</HEAD>
<BODY>
<%
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
java.sql.Connection conn = java.sql.DriverManager.getConnection("jdbc:odbc:students");
java.sql.Statement stmt = conn.createStatement();
String sql="select * from student";   //定义查询的SQL语句
ResultSet rs=stmt.executeQuery(sql);   //执行查询
Document document=new Document(new Element("student_list"));//创建文档
java.sql.ResultSetMetaData rsmd = rs.getMetaData();  //获取字段名
int numberOfColumns = rsmd.getColumnCount(); //获取字段数
int i=0;
while(rs.next()){ //将查询结果取出
    Element element0=new Element("student");  //创建元素 生成JDOM树
    document.getRootElement().addContent(element0);
    for (i=1; i<=numberOfColumns;i++)
 {
  String date=new String(rs.getString(i)); //代码转换
  Element element=new Element(rsmd.getColumnName(i)).setText(date);
  element0.addContent(element);
 }
}
rs.close();                            //关闭结果集
stmt.close();                       //关闭statement
conn.close();                      //关闭连接

XMLOutputter outp = new XMLOutputter(Format.getPrettyFormat());
outp.output(document, new FileOutputStream("d:\\data.xml")); //输出XML文档
out.print("XML 文档生成完毕！");
%>
</BODY>
</HTML>