亚洲成a人片在线观看日本麻豆 ,亚洲无人区视频大全,国产精品亚洲成在人线

jxl的一些�ȝ��

zeroone0 — Fri, 21 Apr 2006 08:12:00 GMT

要往xls文�g里面写入数据的时候需要注意的是第一要新��Z��个xls文�g
OutputStream os=new FileOutputStream("c:\\excel2.xls");

再徏完这个文件的时候再建立工作文�g
jxl.write.WritableWorkbook wwb = Workbook.createWorkbook(new File(os));

如果�q�个文�g已经存在,那么我们可以在这个文仉��面加入一个sheet��Z��和以前的数据�q�行分开;
jxl.write.WritableSheet ws = wwb.createSheet("Test Sheet 1", 0);
在createSheet�Ҏ(gu��)��里前面的参数是sheet名，后面是要操作的sheet�?

接下来就可以往�q�个文�g里面写入数据�?

写入数据的时候注意的格式

�Q?�Q�添加的字体样式
jxl.write.WritableFont wf = new jxl.write.WritableFont(WritableFont.TIMES, 18, WritableFont.BOLD, true);
WritableFont()�Ҏ(gu��)��里参数说明：(x��)
�q�个�Ҏ(gu��)��是一个容器，可以放进��d��多属�?
�W�一�? TIMES是字体大��，他写的是18
�W�二�? BOLD是判断是否�ؓ(f��)斜体,选择true时�ؓ(f��)斜体
�W�三�? ARIAL
�W�四�? UnderlineStyle.NO_UNDERLINE 下划�U?
�W�五�? jxl.format.Colour.RED 字体颜色是红色的

jxl.write.WritableCellFormat wcfF = new jxl.write.WritableCellFormat(wf);

jxl.write.Label labelC = new jxl.write.Label(0, 0, "This is a Label cell"�Q�wcfF);
ws.addCell(labelC);
在Label()�Ҏ(gu��)��里面有三个参�?
�W�一个是代表列数,
�W�二是代表行敎ͼ�
�W�三个代表要写入的内�?
�W�四个是可选项�Q�是输入�q�个label里面的样�?
然后通过写sheet的方法addCell�Q�）把内容写�q�sheet里面�?

�Q?�Q�添加带有formatting的Number对象
jxl.write.NumberFormat nf = new jxl.write.NumberFormat("#.##");

�Q?�Q�添加Number对象
�Q?.1�Q�显�C�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);
Number()�Ҏ(gu��)��参数说明:
前两上表�C��入的位置
�W�三个表�C��入的内容

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

�Q?�Q�添加DateTime对象
jxl.write.DateTime labelDT = new jxl.write.DateTime(0, 3, new java.util.Date());
ws.addCell(labelDT);
DateTime()�Ҏ(gu��)��的参数说�?
前两个表�C��入的位置
�W�三个表�C��入的当前旉��

�Q?�Q�添加带有formatting的DateFormat对象
�q�个昄��当前旉��的所有信息，包括�q�月日小时分�U?
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);

�Q?�Q�添加带有字体颜色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);

import="jxl.format.*
jxl.write.WritableFont wfc = new jxl.write.WritableFont(WritableFont.ARIAL,20,WritableFont.BOLD,false,UnderlineStyle.NO_UNDERLINE,jxl.format.Colour.GREEN);

�Q?�Q�设�|�单元格样式

jxl.write.WritableCellFormat wcfFC = new jxl.write.WritableCellFormat(wfc);
wcfFC.setBackGround(jxl.format.Colour.RED);//讄��单元格的颜色为红�?
wcfFC = new jxl.write.Label(6,0,"i love china",wcfFC);

FROM: http://forum.javaeye.com/viewtopic.php?t=4157&postdays=0&postorder=asc&start=0

zeroone0 2006-04-21 16:12 发表评论

JAVA生成EXCEL文�g

zeroone0 — Fri, 21 Apr 2006 07:59:00 GMT

1 从Excel文�g��d��数据�?/font>

Java Excel API既可以从本地文�g�pȝ��的一个文�?.xls)�Q�也可以从输入流中读取Excel数据表。读取Excel数据表的�W�一步是创徏Workbook(术语�Q�工作薄)�Q�下面的代码片段举例说明了应该如何操作：(x��)(完整代码见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();
}

一旦创��Z��Workbook�Q�我们就可以通过它来讉K��Excel Sheet(术语�Q�工作表)。参考下面的代码片段�Q?/p>

												
														//获取�W�一张Sheet�?
Sheet rs = rwb.getSheet(0);

我们既可能通过Sheet的名�U�来讉K��它，也可以通过下标来访问它。如果通过下标来访问的话，要注意的一�Ҏ(gu��)��下标�?开始，��像数组一栗��?/p>

一旦得��C��Sheet�Q�我们就可以通过它来讉K��Excel Cell(术语�Q�单元格)。参考下面的代码片段�Q?/p>

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

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

//获取�W�二行，�W�二列的�?
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()�Ҏ(gu��)��Q�它可以��Q何类型的Cell值都作�ؓ(f��)一个字�W�串�q�回。示例代码中Cell(0, 0)是文本型�Q�Cell(1, 0)是数字型�Q�Cell(1,1)是日期型�Q�通过getContents()�Q�三�U�类型的�q�回值都是字�W�型�?/p>

如果有需要知道Cell内容的确切类型，API也提供了一�p�d��的方法。参考下面的代码片段�Q?/p>

												
														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()�Ҏ(gu��)��可以获得该单元格的类型，然后与API提供的基本类型相匚w��Q�强制�{换成相应的类型，最后调用相应的取值方法getXXX()�Q�就可以得到��定�c�d��的倹{��API提供了以下基本类型，与Excel的数据格式相对应�Q�如下图所�C�：(x��)

每种�c�d��的具体意义，请参见Java Excel API Document�?/p>

当你完成对Excel�?sh��)子表格数据的处理后�Q�一定要使用close()�Ҏ(gu��)��来关闭先前创建的对象�Q�以释放��d��数据表的�q�程中所占用的内存空��_(d��)��在读取大量数据时昑־��ؓ(f��)重要。参考如下代码片�D�：(x��)

												
														//操作完成�Ӟ��关闭对象�Q�释攑֍�用的内存�I�间
rwb.close();

Java Excel API提供了许多访问Excel数据表的�Ҏ(gu��)��Q�在�q�里我只��要地介绍几个常用的方法，其它的方法请参考附录中的Java Excel API Document�?/p>

Workbook�c�L��供的�Ҏ(gu��)��

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

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

2. Sheet[] getSheets()
�q�回工作薄（Workbook�Q�中工作表（Sheet�Q�对象数�l�，�C�Z��Q?

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

3. String getVersion()
�q�回正在使用的API的版本号�Q�好像是没什么太大的作用�?

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

Sheet接口提供的方�?/b>

1) String getName()
获取Sheet的名�U�ͼ��C�Z��Q?

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

2) int getColumns()
获取Sheet表中所包含的��d��敎ͼ��C�Z��Q?

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

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

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

4) int getRows()
获取Sheet表中所包含的总行敎ͼ��C�Z��Q?

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

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

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)
获取指定单元格的对象引用�Q�需要注意的是它的两个参敎ͼ��W�一个是列数�Q�第二个是行敎ͼ��q�与通常的行、列�l�合有些不同�?

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

2 生成新的Excel工作�?/font>

下面的代码主要是向大家介�l�如何生成简单的Excel工作表，在这里单元格的内�Ҏ(gu��)��不带��M��修饰�?如：(x��)字体�Q�颜色等�{?�Q�所有的内容都作为字�W�串写入�?完整代码见ExcelWriting.java)

与读取Excel工作表相��|��首先要��用Workbook�cȝ��工厂�Ҏ(gu��)��创徏一个可写入的工作薄(Workbook)对象�Q�这里要注意的是�Q�只能通过API提供的工厂方法来创徏Workbook�Q�而不能��用WritableWorkbook的构造函敎ͼ�因�ؓ(f��)�c�WritableWorkbook的构造函��Cؓ(f��)protected�c�d��。示例代码片�D�如下：(x��)

import java.io.*; import jxl.*; import jxl.write.*; �?�?�?�? try { //构徏Workbook对象, 只读Workbook对象 //Method 1�Q�创建可写入的Excel工作�? jxl.write.WritableWorkbook wwb = Workbook.createWorkbook(new File(targetfile)); //Method 2�Q�将WritableWorkbook直接写入到输出流 /* OutputStream os = new FileOutputStream(targetfile); jxl.write.WritableWorkbook wwb = Workbook.createWorkbook(os); */ } catch (Exception e) { e.printStackTrace(); }

API提供了两�U�方式来处理可写入的输出��，一�U�是直接生成本地文�g�Q�如果文件名不带全�\径的话，�~�省的文件会(x��)定位在当前目录，如果文�g名带有全路径的话�Q�则生成的Excel文�g则会(x��)定位在相应的目录�Q�另外一�U�是��Excel对象直接写入到输出流�Q�例如：(x��)用户通过��览器来讉K��Web服务器，如果HTTP头设�|�正��的话，��览器自动调用客��L(f��ng)��的Excel应用�E�序�Q�来昄��动态生成的Excel�?sh��)子表格�?/p>
接下来就是要创徏工作表，创徏工作表的�Ҏ(gu��)��与创建工作薄的方法几乎一��P��同样是通过工厂模式�Ҏ(gu��)��获得相应的对象，该方法需要两个参敎ͼ�一个是工作表的名称�Q�另一个是工作表在工作薄中的位�|�，参考下面的代码片段�Q?/p>

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

"�q�锅也支好了�Q�材料也准备齐全了，可以开始下锅了�Q?�Q�现在要做的只是实例化API所提供的Excel基本数据�c�d��Q��ƈ��它们添加到工作表中��可以了�Q�参考下面的代码片段�Q?/p>

//1.��d��Label对象 jxl.write.Label labelC = new jxl.write.Label(0, 0, "This is a Label cell"); ws.addCell(labelC); //��d��带有字型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); //��d��带有字体颜色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.��d��Number对象 jxl.write.Number labelN = new jxl.write.Number(0, 1, 3.1415926); ws.addCell(labelN); //��d��带有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.��d��Boolean对象 jxl.write.Boolean labelB = new jxl.write.Boolean(0, 2, false); ws.addCell(labelB); //4.��d��DateTime对象 jxl.write.DateTime labelDT = new jxl.write.DateTime(0, 3, new java.util.Date()); ws.addCell(labelDT); //��d��带有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);

�q�里有两点大家要引�v大家的注意。第一点，在构造单元格�Ӟ��单元格在工作表中的位�|�就已经��定了。一旦创建后�Q�单元格的位�|�是不能够变更的�Q�尽��单元格的内�Ҏ(gu��)��可以改变的。第二点�Q�单元格的定位是按照下面�q�样的规�?column, row)�Q�而且下标都是�?开始，例如�Q�A1被存储在(0, 0)�Q�B1被存储在(1, 0)�?/p>
最后，不要忘记关闭打开的Excel工作薄对象，以释攑֍�用的内存�Q�参见下面的代码片段�Q?/p>

//写入Exel工作�? wwb.write(); //关闭Excel工作薄对�? wwb.close();

�q�可能与��d��Excel文�g的操作有��少不同�Q�在关闭Excel对象之前�Q�你必须要先调用write()�Ҏ(gu��)��Q�因为先前的操作都是存储在缓存中的，所以要通过该方法将操作的内容保存在文�g中。如果你先关闭了Excel对象�Q�那么只能得��C��张空的工作薄了�?/p>
3 拯��、更新Excel工作�?/font>

接下来简要介�l�一下如何更��C��个已�l�存在的工作薄，主要是下面二步操作，�W�一步是构造只�ȝ��Excel工作薄，�W�二步是利用已经创徏的Excel工作薄创建新的可写入的Excel工作薄，参考下面的代码片段�Q?完整代码见ExcelModifying.java)

//创徏只读的Excel工作薄的对象 jxl.Workbook rw = jxl.Workbook.getWorkbook(new File(sourcefile)); //创徏可写入的Excel工作薄对�? jxl.write.WritableWorkbook wwb = Workbook.createWorkbook(new File(targetfile), rw); //��d��W�一张工作表 jxl.write.WritableSheet ws = wwb.getSheet(0); //获得�W�一个单元格对象 jxl.write.WritableCell wc = ws.getWritableCell(0, 0); //判断单元格的�c�d��, 做出相应的�{�? 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();

之所以��用这�U�方式构建Excel对象�Q�完全是因�ؓ(f��)效率的原因，因�ؓ(f��)上面的示例才是API的主要应用。�ؓ(f��)了提高性能�Q�在��d��工作表时�Q�与数据相关的一些输��Z��息，所有的格式信息�Q�如�Q�字体、颜色等�{�，是不被处理的�Q�因为我们的目的是获得行数据的��|��既��没有了修饎ͼ�也不�?x��)对行数据的��g�生什么媄响。唯一的不利之处就是，在内存中�?x��)同时保存两个同��L(f��ng)��工作表，�q�样当工作表体积比较大时�Q�会(x��)占用相当大的内存�Q�但现在好像内存的大��ƈ不是什么关键因素了�?/p>
一旦获得了可写入的工作表对象，我们��可以对单元格对象进行更新的操作了，在这里我们不必调用API提供的add()�Ҏ(gu��)��Q�因为单元格已经于工作表当中�Q�所以我们只需要调用相应的setXXX()�Ҏ(gu��)��Q�就可以完成更新的操作了�?/p>
��单元格原有的格式化修饰是不能去掉的�Q�我们还是可以将新的单元��g��饰加上去�Q�以使单元格的内容以不同的�Ş式表现�?/p>
新生成的工作表对象是可写入的�Q�我们除了更新原有的单元格外�Q�还可以��d��新的单元格到工作表中�Q�这与示�?的操作是完全一��L(f��ng)��?/p>
最后，不要忘记调用write()�Ҏ(gu��)��Q�将更新的内容写入到文�g中，然后关闭工作薄对象，�q�里有两个工作薄对象要关闭，一个是只读的，另外一个是可写入的�?br />
FROM: http://www-128.ibm.com/developerworks/cn/java/l-javaExcel/index.html

zeroone0 2006-04-21 15:59 发表评论

Java Annotation

zeroone0 — Thu, 20 Apr 2006 07:30:00 GMT
一、Annotation�I�竟是什么？

Annotation提供了一条与�E�序元素兌��M��信息或者�Q何元数据�Q�metadata�Q�的途径。从某些斚w��看，annotation��像修饰�W�一栯��使用�Q��ƈ应用于包、类型、构造方法、方法、成员变量、参数、本地变量的声明中。这些信息被存储在annotation的“name=value”结构对中。annotation�c�d��是一�U�接口，能够通过java反射API的方式提供对其信息的讉K��?br />
annotation能被用来为某个程序元素（�c�R��方法、成员变量等�Q�关联�Q何的信息。需要注意的是，�q�里存在着一个基本的潜规则：(x��)annotaion不能影响�E�序代码的执行，无论增加、删除annotation�Q�代码都始终如一的执行。另外，��管一些annotation通过java的反��api�Ҏ(gu��)��在运行时被访问，而java语言解释器在工作时忽略了�q�些annotation。正是由于java虚拟机忽略了annotation�Q�导致了annotation�c�d��在代码中是“不起作用”的�Q�只有通过某种配套的工��h��?x��)对annotation�c�d��中的信息�q�行讉K��和处理。本文中��涵盖标准的annotation和meta-annotation�c�d��Q�陪伴这些annotation�c�d��的工��h��java�~�译器（当然要以某种�Ҏ(gu��)��的方式处理它们）�?br />
�׃��上述原因�Q�annotation在��用时十分��ѝ��一个本地变量可以被一个以NonNull命名的annotation�c�d��所标注�Q�来作�ؓ(f��)对这个本地变量不能被赋予null值的断言。而我们可以编写与之配套的一个annotation代码分析工具�Q��用它来对��h��前面变量的代码进行解析，�q�且��试验证�q�个断言。当然这些代码�ƈ不必自己�~�写。在JDK安装后，在JDK/bin目录中可以找到名为“apt”的工具�Q�它提供了处理annotation的框�Ӟ��(x��)它启动后扫描源代码中的annotation�Q��ƈ调用我们定义好的annotation处理器完成我们所要完成的工作�Q�比如验证前面例子中的断�a��Q�。说到这里，annotation的强大功能似乎可以替代XDoclet�q�类的工具了�Q�随着我们的深入，大家�?x��)更加坚信这一炏V�?br />注：(x��)详细描述请参看jsr250规范�Q?br />http://www.jcp.org/aboutJava/communityprocess/pfd/jsr250/

二、Annotation的定义：(x��)

�q�段文字开始介�l�annotation相关技术。在此大家将看到java5.0的标准annotation�c�d��Q�这�U�标准类型就是前文中所说的“内建”类型，它们可以直接被javac支持。可喜的是，在java6.0beta版中的javac已经加入了对自定义annotation的支持�?br />
1。Annotation的概念和语法�Q?/span>

首先�Q�关键的概念是理解annotation是与一个程序元素相兌��信息或者元数据的标注。它从不影响java�E�序的执行，但是对例如编译器警告或者像文档生成器等辅助工具产生影响�?br />
下面是常用的annotation列表�Q�我们应该注意在annotation和annotation�c�d��之间的不同：(x��)

A.annotation�Q?/span>
annotation使用了在java5.0所带来的新语法�Q�它的行为十分类似public、final�q�样的修饰符。每个annotation��h��一个名字和成员个数>=0。每个annotation的成员具有被�U�Cؓ(f��)name=value对的名字和��|��像javabean一��P��Q�name=value装蝲了annotation的信息�?br />
B.annotation�c�d��Q?/span>
annotation�c�d��定义了annotation的名字、类型、成员默认倹{��一个annotation�c�d��可以说是一个特�D�的java接口�Q�它的成员变量是受限制的�Q�而声明annotation�c�d��旉��要��用新语法。当我们通过java反射api讉K��a(ch��n)nnotation�Ӟ��q�回值将是一个实��C��该annotation�c�d��接口的对象，通过讉K��q�个对象我们能方便的讉K��到其annotation成员。后面的章节��提到在java5.0的java.lang包里包含�?个标准annotation�c�d��?br />
C.annotation成员�Q?/span>
annotation的成员在annotation�c�d��中以无参数的�Ҏ(gu��)��的�Ş式被声明。其�Ҏ(gu��)��名和�q�回值定义了该成员的名字和类型。在此有一个特定的默认语法�Q�允许声明�Q何annotation成员的默认��|��(x��)一个annotation可以��name=value对作为没有定义默认值的annotation成员的��|��当然也可以��用name=value�Ҏ(gu��)��覆盖其它成员默认倹{��这一�Ҏ(gu��)��些近似类的��承特性，父类的构造函数可以作为子�cȝ��默认构造函敎ͼ�但是也可以被子类覆盖�?br />
D.marker annotation�c�d��Q?/span>
一个没有成员定义的annotation�c�d��被称为marker annotation。这�U�annotation�c�d��仅��用自�w�的存在与否来�ؓ(f��)我们提供信息。如后面要说的Override�?br />
E.meta-annotation�Q?/span>
meta-annotation也称为元annotation�Q�它是被用来声明annotation�c�d��的annotation。Java5.0提供了一些标准的�?annotation�c�d��。下面介�l�的target、retention��是meta-annotation�?br />
F.target�Q?/span>
annotation的target是一个被标注的程序元素。target说明了annotation所修饰的对象范��_(d��)��(x��)annotation可被用于packages、types�Q�类、接口、枚举、annotation�c�d��Q�、类型成员（�Ҏ(gu��)��、构造方法、成员变量、枚丑ր�|��、方法参数和本地变量�Q�如循环变量、catch参数�Q�。在annotation�c�d��的声明中使用了target可更加明晰其修饰的目标�?br />
G.retention�Q?/span>
annotation的retention定义了该annotation被保留的旉��长短�Q�某些annotation仅出现在源代码中�Q�而被�~�译器丢弃；而另一些却被编译在class文�g中；�~�译在class文�g中的annotation可能�?x��)被虚拟机忽略，而另一些在class被装载时��被��d��Q�请注意�q�不影响class的执行，因�ؓ(f��)annotation与class在��用上是被分离的）。��用这个meta-annotation可以对annotation的“生命周期”限制�?br />
H.metadata�Q?/span>
�׃��metadata被广泛��用于各种计算机开发过�E�中�Q�所以当我们在这里谈论的metadata卛_��数据通常指被annotation装蝲的信息或者annotation本��n�?br />
2。��用标准Annotation�Q?/span>
java5.0在java.lang包中定义�?�U�标准的annotation�c�d��Q?br />
A.Override�Q?/span>
java.lang.Override是一个marker annotation�c�d��Q�它被用作标注方法。它说明了被标注的方法重载了父类的方法，起到了断�a�的作用。如果我们��用了�q�种annotation在一个没有覆盖父�c�L��法的�Ҏ(gu��)��Ӟ��java�~�译器将以一个编译错误来警示�?br />�q�个annotaton常常在我们试图覆盖父�c�L��法而确又写错了�Ҏ(gu��)��名时发挥威力�?br />
使用�Ҏ(gu��)��极其��单：(x��)在��用此annotation时只要在被修饰的�Ҏ(gu��)��前面加上@Override�?br />下面的代码是一个��用@Override修饰一个企��N��载父�cȝ��toString�Ҏ(gu��)��Q�而又存在拼写错误的sample�Q?br />

@Override
public String toSting() {   // 注意�Ҏ(gu��)��名拼写错�?br />    return "[" + super.toString() + "]";
}

B.Deprecated�Q?/span>
同样Deprecated也是一个marker annotation。当一个类型或者类型成员��用@Deprecated修饰的话�Q�编译器��不鼓励使用�q�个被标注的�E�序元素。而且�q�种修饰��h��一定的“�g�l�性”：(x��)如果我们在代码中通过�l�承或者覆盖的方式使用了这个过时的�c�d��或者成员，虽然�l�承或者覆盖后的类型或者成员�ƈ不是被声明�ؓ(f��)@Deprecated�Q�但�~�译器仍然要报警�?br />值得注意�Q�@Deprecated�q�个annotation�c�d��和javadoc中的@deprecated�q�个tag是有区别的：(x��)前者是java�~�译器识别的�Q�而后者是被javadoc工具所识别用来生成文档�Q�包含程序成员�ؓ(f��)什么已�l�过时、它应当如何被禁止或者替代的描述�Q��?br />在java5.0�Q�java�~�译器仍然象其从前版本那样寻找@deprecated�q�个javadoc tag�Q��ƈ使用它们产生警告信息。但是这�U�状况将在后�l�版本中改变�Q�我们应在现在就开始��用@Deprecated来修饰过时的�Ҏ(gu��)��而不是@deprecated javadoc tag�?br />

下面是一�D��用@Deprecated的代码：(x��)
/**
* �q�里是javadoc的@deprecated声明.
* @deprecated No one has players for this format any more.  Use VHS instead.
*/
@Deprecated public class Betamax { ... }

C.SuppressWarnings�Q?/span>
@SuppressWarnings被用于有选择的关闭编译器对类、方法、成员变量、变量初始化的警告。在java5.0�Q�sun提供的javac�~�译器�ؓ(f��)我们提供�?Xlint选项来�ɾ~�译器对合法的程序代码提��告，此种警告从某�U�程度上代表了程序错误。例如当我们使用一个generic collection�c�而又没有提供它的�c�d��Ӟ��~�译器将提示�?unchecked warning"的警告�?br />
通常当这�U�情况发生时�Q�我们就需要查扑ּ�赯��告的代码。如果它真的表示错误�Q�我们就需要纠正它。例如如果警告信息表明我们代码中的switch语句没有覆盖所有可能的case�Q�那么我们就应增加一个默认的case来避免这�U�警告�?br />�总��Q�有时我们无法避免这�U�警告，例如�Q�我们��用必��d��非generic的旧代码交互的generic collection�c�L��Q�我们不能避免这个unchecked warning。此时@SuppressWarning��p��z�上用场了，在调用的�Ҏ(gu��)��前增加@SuppressWarnings修饰�Q�告诉编译器停止�Ҏ(gu��)��Ҏ(gu��)��的警告�?br />SuppressWarning不是一个marker annotation。它有一个类型�ؓ(f��)String[]的成员，�q�个成员的��gؓ(f��)被禁止的警告名。对于javac�~�译器来�Ԍ��?Xlint选项有效的警告名也同样对@SuppressWarings有效�Q�同时编译器忽略掉无法识别的警告名�?br />
annotation语法允许在annotation名后跟括��P��括号中是使用逗号分割的name=value对用于�ؓ(f��)annotation的成员赋��|��(x��)

@SuppressWarnings(value={"unchecked","fallthrough"})
public void lintTrap() { /* sloppy method body omitted */ }

在这个例子中SuppressWarnings annotation�c�d��只定义了一个单一的成员，所以只有一个简单的value={...}作�ؓ(f��)name=value寏V��又�׃��成员值是一个数�l�，故��用大括号来声明数�l�倹{�?br />
注意�Q�我们可以在下面的情况中�~�写annotation�Q�当annotation只有单一成员�Q��ƈ成员命名�?value="。这时可以省�?value="。比如将上面的SuppressWarnings annotation�q�行�~�写�Q?br />

@SuppressWarnings({"unchecked","fallthrough"})

如果SuppressWarnings所声明的被��止警告个数��Z��个时�Q�可以省��d��括号�Q?br />

@SuppressWarnings("unchecked")

3。Annotation语法�Q?/span>

在上一个章节中�Q�我们看��C��写marker annotation和单一成员annotation的语法。下面本人来介绍一下完整的语法�Q?br />
annotation由“@+annotation�c�d��名称+(..逗号分割的name-value�?..)”组成。其中成员可以按照�Q何的��序。如果annotation�c�d��定义了某个成员的默认��|��则这个成员可以被省略。成员值必��Mؓ(f��)�~�译时常量、内嵌的annotation或者数�l��?br />
下面我们��定义一个annotation�c�d��名�ؓ(f��)Reviews�Q�它有一个由@Review annotation数组构成的成员。这个@Review annotation�c�d��有三个成员：(x��)"reviewer"是一个字�W�串�Q?comment" 是一个具有默认值的可选的字符�Ԍ��"grade"是一个Review.Grade枚�D�c�d��倹{�?br />

@Reviews({  // Single-value annotation, so "value=" is omitted here
    @Review(grade=Review.Grade.EXCELLENT,
            reviewer="df"),
    @Review(grade=Review.Grade.UNSATISFACTORY,
            reviewer="eg",
            comment="This method needs an @Override annotation")
})

annotation语法的另一个重要规则是没有�E�序成员可以有多于一个的同一annotation实例。例如在一个类中简单的攄��多个@Review annotation。这也是在上面代码中定义@Reviews annotation�c�d��数组的原因�?br />
4。Annotation成员�c�d��和��|��(x��)

annotation成员必须是非�I�的�~�译时常量表辑ּ�。可用的成员�c�d��为：(x��)primitive�c�d��? String, Class, enumerated�c�d��, annotation�c�d��, 和前面类型的数组�?br />
下面我们定义了一个名为UncheckedExceptions 的annotation�c�d��Q�它的成员是一个扩展了RuntimeException�cȝ��c�L��l��?br />

@UncheckedExceptions({
    IllegalArgumentException.class, StringIndexOutOfBoundsException.class
})

5。Annotation的目标：(x��)

annotation通常被放在类型定义和成员定义的前面。然而它也出现在package、方法参数、本地变量的前面。下面，我们来讨��Z��下这些不大常用的写法�Q?br />
package annotation出现在package声明的前面�?br />下面的例子package-info.java中不包含��M��的公��q��型定义，却包含一个可选的javadoc注释�?br />

/**
* This package holds my custom annotation types.
*/
@com.davidflanagan.annotations.Author("David Flanagan")
package com.davidflanagan.annotations;

当package-info.java文�g被编译时�Q�它?y��u)��生名为包含annotation�Q�特�D�的接口�Q�声明的package-info.class的类。这个接口没有成员，它的名字package-info不是一个合法的java标识�Q�所以它不能用在java源代码中。这个接口的存在只是��单的被看作一个�ؓ(f��)package annotation准备的占位符�?br />
用于修饰�Ҏ(gu��)��参数、catch参数、本地变量的annotation只是��单的出现在这些程序成员的修饰�W�位�|�。java�c�L��件格式没有�ؓ(f��)本地变量或者catch参数存储annotation作准备，所以这些annotation��L��保留在源代码�U�别�Q�source retention�Q�；�Ҏ(gu��)��参数annotation能够保存在类文�g中，也可以在保留到运行时�?br />
最后，��h��意，枚�D�c�d��定义中不允许��M��的修饰符修饰其枚丑ր�{�?br />
6。Annotation和默认��|��(x��)
在Annotation中，没有默认值的成员必须有一个成员倹{��而如何理解默认值是如何被处理就是一个很重要的细节：(x��)annotation�c�d��所定义的成员默认��D��存储在class文�g中，不被�~�译到annotation里面。如果我们修改一个annotation�c�d��使其成员的默认值发生了改变�Q�这个改变对于所有此�c�d��的annotation中没有明��提供成员值的成员产生影响�Q�即修改了该成员的成员��|��。即使在annotation�c�d��使其成员的默认��D��改变后annotation从没被重新编译过�Q�该�c�d��的annotation(改变前已�l�被�~�译�?也受到媄响�?br />
三、Annotation工作原理�Q?/span>

Annotation与反��?/span>
在java5.0中Java.lang.reflect提供的反��API被扩充了��d��q�行时annotation的能力。让我们回顾一下前面所讲的�Q�一个annotation�c�d��被定义�ؓ(f��)runtime retention后，它才是在�q�行时可见，当class文�g被装载时被保存在class文�g中的annotation才会(x��)被虚拟机��d��。那么reflect是如何帮助我们访问class中的annotation呢？

下文��在java.lang.reflect用于annotation的新�Ҏ(gu��)��，其中java.lang.reflect.AnnotatedElement是重要的接口�Q�它代表了提供查询annotation能力的程序成员。这个接口被java.lang.Package、java.lang.Class实现�Q��ƈ间接地被Method�c�R��Constructor�c�R��java.lang.reflect的Field�c�d��现。而annotation中的�Ҏ(gu��)��参数可以通过Method�c�R��Constructor�cȝ��getParameterAnnotations()�Ҏ(gu��)��获得�?br />
下面的代码��用了AnnotatedElement�cȝ��isAnnotationPresent()�Ҏ(gu��)��判断某个�Ҏ(gu��)��是否��h��@Unstable annotation�Q�从而断�a�此方法是否稳定：(x��)

import java.lang.reflect.*;

Class c = WhizzBangClass.class;
Method m = c.getMethod("whizzy", int.class, int.class);
boolean unstable = m.isAnnotationPresent(Unstable.class);

isAnnotationPresent()�Ҏ(gu��)��对于��查marker annotation是十分有用的�Q�因为marker annotation没有成员变量�Q�所以我们只要知道class的方法是否��用了annotation修饰��可以了。而当处理��h��成员的annotation�Ӟ��我们通过使用getAnnotation()�Ҏ(gu��)��来获得annotation的成员信息（成员名称、成员��|��。这里我们看��C��一套优��的java annotation�pȝ��Q�如果annotation存在�Q�那么实��C��相应的annotation�c�d��接口的对象将被getAnnotation()�Ҏ(gu��)��q�回�Q�接着调用定义在annotation�c�d��中的成员�Ҏ(gu��)��可以方便地获得�Q何成员倹{�?br />
回想一下，前面介绍的@Reviews annotation�Q�如果这个annotation�c�d��被声明�ؓ(f��)runtime retention的话�Q�我们通过下面的代码来讉K��@Reviews annotation的成员��|��(x��)

AnnotatedElement target = WhizzBangClass.class; //获得被查询的AnnotatedElement
// 查询AnnotatedElement的@Reviews annotation信息
Reviews annotation = target.getAnnotation(Reviews.class);
// 因�ؓ(f��)@Reviews annotation�c�d��的成员�ؓ(f��)@Review annotation�c�d��的数�l�，
// 所以下面声明了Review[] reviews保存@Reviews annotation�c�d��的value成员倹{�?br />Review[] reviews = annotation.value();
// 查询每个@Review annotation的成员信�?br />for(Review r : reviews) {
    Review.Grade grade = r.grade();
    String reviewer = r.reviewer();
    String comment = r.comment();
    System.out.printf("%s assigned a grade of %s and comment '%s'%n",
                      reviewer, grade, comment);
}

四、如何自定义Annotation�Q?/span>

1�Q�详解annotation与接口的异同�Q?/span>
因�ؓ(f��)annotation�c�d��是一个非凡的接口�Q�所以两者之间存在着某些差异�Q?br />
A.Annotation�c�d��使用关键字@interface而不是interface�?/span>
�q�个关键字声明隐含了一个信息：(x��)它是�l�承了java.lang.annotation.Annotation接口�Q��ƈ非声明了一个interface�?br />
B.Annotation�c�d��、方法定义是独特的、受限制的�?/span>
Annotation�c�d��的方法必��d��明�ؓ(f��)无参数、无异常抛出的。这些方法定义了annotation的成员：(x��)�Ҏ(gu��)��名成��Z��成员名，而方法返回值成��Z��成员的类型。而方法返回值类型必��Mؓ(f��)primitive�c�d��、Class�c�d��、枚丄��型、annotation�c�d��或者由前面�c�d��之一作�ؓ(f��)元素的一�l�数�l�。方法的后面可以使用default和一个默认数值来声明成员的默认��|��null不能作�ؓ(f��)成员默认��|��q�与我们在非annotation�c�d��中定义方法有很大不同�?br />Annotation�c�d��和它的方法不能��用annotation�c�d��的参数、成员不能是generic。只有返回值类型是Class的方法可以在annotation�c�d��中��用generic�Q�因为此�Ҏ(gu��)��能够用类转换��各�U�类型�{换�ؓ(f��)Class�?br />
C.Annotation�c�d��又与接口有着�q�似之处�?/span>
它们可以定义帔R��、静态成员类型（比如枚�D�c�d��定义�Q�。Annotation�c�d��也可以如接口一般被实现或者��ѝ�?br />
2�Q�实例：(x��)
下面�Q�我们将看到如何定义annotation�c�d��的example。它展示了annotation�c�d��声明以及(qi��ng)@interface与interface之间的不同：(x��)

package com.davidflanagan.annotations;
import java.lang.annotation.*;

/**
* 使用annotation来描�q�那些被标注的成员是不稳定的�Q�需要更�?br />*/
@Retention(RetentionPolicy.RUNTIME)
public @interface Unstable {}

下面的另一个example只定义了一个成员。�ƈ通过��这个成员命名�ؓ(f��)value�Q��我们可以方便的��用这�U�annotation的快捷声明方式：(x��)

/**
* 使用Author�q�个annotation定义在程序中指出代码的作�?br /> */
public @interface Author {
    /** �q�回作者名 */
    String value();
}

以下的example更加复杂。Reviews annotation�c�d��只有一个成员，但是�q�个成员的类型是复杂的：(x��)由Review annotation�l�成的数�l�。Review annotation�c�d��?个成员：(x��)枚�D�c�d��成员grade、表�C�Review名称的字�W�串�c�d��成员Reviewer、具有默认值的字符串类型成员Comment�?br />

import java.lang.annotation.*;

/**
* Reviews annotation�c�d��只有一个成员，
* 但是�q�个成员的类型是复杂的：(x��)由Review annotation�l�成的数�l?br /> */
@Retention(RetentionPolicy.RUNTIME)
public @interface Reviews {
    Review[] value();
}

/**
* Review annotation�c�d��?个成员：(x��)
* 枚�D�c�d��成员grade�?br />  * 表示Review名称的字�W�串�c�d��成员Reviewer�?br />  * ��h��默认值的字符串类型成员Comment�?br /> */
public @interface Review {
    // 内嵌的枚丄��?br />    public static enum Grade { EXCELLENT, SATISFACTORY, UNSATISFACTORY };

    // 下面的方法定义了annotation的成�?br />    Grade grade();
    String reviewer();
    String comment() default "";
}

最后，我们来定义一个annotation�Ҏ(gu��)��用于�|�列出类�q�行中所有的unchecked异常�Q�上文已�l�提到这�U�情况不一定是错误�Q�。这个annotation�c�d��一个数�l�作��Z��唯一的成员。数�l�中的每个元素都是异常类。�ؓ(f��)了加强对未检查的异常�Q�此�c�d��帔R��是在�q�行时抛出）�q�行报告�Q�我们可以在代码中对异常的类型进行限�Ӟ��(x��)

public @interface UncheckedExceptions {
    Class[] value();
}

五、Meta-Annotation

Annotation�c�d��可以被它们自己所标注。Java5.0定义�?个标准的meta-annotation�c�d��Q�它们被用来提供对其它annotation�c�d��作说明。这些类型和它们所支持的类在java.lang.annotation包中可以扑ֈ�。如果需要更详细的信息可以参考jdk5.0手册�?br />
1�Q�再谈Target
作�ؓ(f��)meta-annotation�c�d��的Target,它描�q�C��annotation所修饰的程序成员的�c�d��。当一个annotation�c�d��没有Target�Ӟ��它将被作为普通的annotation看待。当��它修饰一个特定的�E�序成员�Ӟ��它将发挥其应用的作用�Q�例如：(x��)Override用于修饰�Ҏ(gu��)��Ӟ��增加了@Target�q�个meta-annotation��׃�ɾ~�译器对annotation作检查，从而去掉修饰错误类型的Override�?br />
Target meta-annotation�c�d��有唯一的value作�ؓ(f��)成员。这个成员的�c�d��是java.lang.annotation.ElementType[]�c�d��的，ElementType�c�d��是可以被标注的程序成员的枚�D�c�d��?br />
2�Q�Retention的用�?/span>
我们在文章的开头曾�l�提到过Retention�Q�但是没有详�l�讲解。Retention描述了annotation是否被编译器丢弃或者保留在class文�g�Q�如果保留在class文�g中，是否在class文�g被装载时被虚拟机��d��。默认情况下�Q�annotation被保存在class文�g中，但在�q�行时�ƈ不能被反��访问。Retention��h��三个取��|��(x��)source、class、runtime�Q�这些取值来自java.lang.annotation.RetentionPolicy的枚丄��型倹{�?br />
Retention meta-annotation�c�d��有唯一的value作�ؓ(f��)成员�Q�它的取值来自java.lang.annotation.RetentionPolicy的枚丄��型倹{�?br />
3�Q�Documented
Documented是一个meta-annotation�c�d��Q�用于描�q�其它类型的annotation应该被作��标注的程序成员的公共API�Q�因此可以被例如javadoc此类的工��h��档化�?br />
Documented是一个marker annotation�Q�没有成员�?br />
4�Q�Inherited
@Inherited meta-annotation也是一个marker annotation�Q�它阐述了某个被标注的类型是被��承的。如果一个��用了@Inherited修饰的annotation�c�d��被用于一个class�Q�则�q�个annotation��被用于该class的子�c�R�?br />
注意�Q�@Inherited annotation�c�d��是被标注�q�的class的子�c�L��l�承。类�q�不从它所实现的接口��承annotation�Q�方法�ƈ不从它所重蝲的方法��承annotation�?br />
值得思考的是，当@Inherited annotation�c�d��标注的annotation的Retention是RetentionPolicy.RUNTIME�Q�则反射API增强了这�U��承性。如果我们��用java.lang.reflect��L��询一个@Inherited annotation�c�d��的annotation�Ӟ��反射代码��查将展开工作�Q�检查class和其父类�Q�直到发现指定的annotation�c�d��被发玎ͼ�或者到辄��l�承�l�构的顶层�?br />

作�?cleverpig(http://blog.matrix.org.cn/page/cleverpig)

zeroone0 2006-04-20 15:30 发表评论

log4j日志��理

zeroone0 — Thu, 06 Apr 2006 15:26:00 GMT
Index

Log4j的类�?
Logger�Q�日志写出器
Logger的输出方�?
Logger的命名规�?
Log level
�C�Z��代码
关于logger的两点说�?
Appender�Q�日志目的地
ConsoleAppender
FileAppender
RollingFileAppender
Layout�Q�日志格式化�?
PatternLayout
patterns in PatternLayout
Configuration�Q�配�|?
默认的log4j初始化过�E?
BasicConfigurator.configure()
xml格式的log4j配置文�g概述
在xml文�g中配�|�a(ch��n)ppender和layout
我自��q��一个��用xml文�g配置log4j环境的很��单的例子
Log4j的编码习(f��n)�?
参考资�?

Log4j的类�?

Logger - 日志写出器，供程序员输出日志信息
Appender - 日志目的圎ͼ�把格式化好的日志信息输出到指定的地方�?
ConsoleAppender - 目的��Cؓ(f��)控制台的Appender
FileAppender - 目的��Cؓ(f��)文�g的Appender
RollingFileAppender - 目的��Cؓ(f��)大小受限的文件的Appender
Layout - 日志格式化器�Q�用来把�E�序员的logging request格式化成字符�?
PatternLayout - 用指定的pattern格式化logging request的Layout

Logger�Q�日志写出器
Logger对象是用来取代System.out或者System.err的日志写出器�Q�用来供�E�序员输出日志信息�?

Logger的输出方�?
Logger�c�d��象提供一�p�d��Ҏ(gu��)��供程序员输出日志信息�?

------ Log4j APIs : class Logger ------

// Printing methods :

public void debug(Object msg);
public void debug(Object msg, Throwable t);

public void info(Object msg);
public void info(Object msg, Throwable t);

public void warn(Object msg);
public void warn(Object msg, Throwable t);

public void error(Object msg);
public void error(Object msg, Throwable t);

public void fatal(Object msg);
public void fatal(Object msg, Throwable t);

// Generic printing method :

public void log(Level l, Object msg);

Logger的命名规�?
Logger�׃��个String�cȝ��名字识别�Q�logger的名字是大小写敏感的�Q�且名字之间��h��l�承的关�p�，子名有父名作为前�~��Q�用点号.分隔。如�Q�x.y是x.y.z的父二Ӏ?

根logger (root logger)是所有logger的祖先，它具有如下属性：(x��)1) 它��L��存在的；2) 它不可以通过名字获得�?
通过调用public static Logger Logger.getRootLogger()获得root logger�Q�通过调用public static Logger Logger.getLogger(String name)或者public static Logger Logger.getLogger(Class clazz)获得�Q�或者创建）一个named logger。后者相当于调用Logger.getLogger(clazz.getName())�?

在某对象中，用该对象所属的�c�Mؓ(f��)参数�Q�调用Logger.getLogger(Class clazz)以获得logger被认为是目前所知的最理智的命名logger的方法�?

Log level
每个logger都被分配了一个日志��?(log level)�Q�用来控制日志信息的输出。未被分配level的logger��承它最�q�的父logger的level�?

每条输出到l(f��)ogger的日志请�?logging request)也都有一个level�Q�如果该request的level大于�{�于该logger的level�Q�则该request��被处理�Q�称为enabled�Q�；否则该request��被忽略。故可得知：(x��)

logger的level��低�Q�表�C��logger��详�l?
logging request的level��高�Q�表�C��logging request��优先输�?

Level�c�M��预定义了五个level�Q�它们的大小关系如下�Q?

Level.ALL < Level.DEBUG < Level.INFO < Level.WARN < Level.ERROR < Level.FATAL < Level.OFF

�C�Z��代码
以下代码��用自己所属的�c�Mؓ(f��)参数�Q�创��Z��个logger�Q�启用默认配�|�，讄��其level�q�向其输��q�logging request�?

import org.apache.log4j.Logger;
import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.Level;

public class Log4jTest {
public static void main(String argv[]) {

// Create a logger by the name of class Log4jTest.

Logger logger = Logger.getLogger(Log4jTest.class);

// Use the default configuration.

BasicConfigurator.configure();

// Set the logger level to Level.INFO

logger.setLevel(Level.INFO);

// This request will be disabled since Level.DEBUG < Level.INFO.

logger.debug("This is debug.");

// These requests will be enabled.

logger.info("This is an info.");
logger.warn("This is a warning.");
logger.error("This is an error.");
logger.fatal("This is a fatal error.");

return;
}
}

关于logger的两点说�?

用同名参数调用Logger.getLogger(String name)��返回同一个logger的引用。故可以在一个地斚w��|�logger�Q�在另外一个地方获得配�|�好的logger�Q�而无��ȝ��互间传递logger的引用�?
logger的创建可以按照�Q意的��序�Q�即�Q�父logger可以后于子logger被创建。log4j��自动维护logger的��承树(w��i)�?
Appender�Q�日志目的地
每个logger都可以拥有一个或者多个appender�Q�每个appender表示一个日志的输出目的圎ͼ�比如console或者某个文件。可以��用Logger.addAppender(Appender app)为logger增加一个appender�Q�可以��用Logger.removeAppender(Appender app)为logger�U�除一个appender�?

默认情况下，logger的additive标志被设�|��ؓ(f��)true�Q�表�C�子logger��承父logger的所有appenders。该选项可以被重新设�|�，表示子logger��不再��承父logger的appenders�?

root logger拥有目标为system.out的consoleAppender�Q�故默认情况下，所有的logger都将�l�承该appender�?

------ Log4j APIs : class Logger ------

// 为logger对象增加或者移除一个Appender对象 :.

public void appAppender(Appender app);
public void removeAppender(Appender app);

// 获得和设�|�a(ch��n)dditive标志�Q�是否��承父logger的appenders :.
// 注意�Q�在讄��a(ch��n)dditive标志为false�Ӟ��必须保证已经��logger讄��了新的appender�Q?:.
// 否则log4j��报错：(x��)log4j:WARN No appenders could be found for logger (x.y.z). :.

public boolean getAdditivity();
public void setAdditivity(boolean additive);

ConsoleAppender
可以使用ConsoleAppender对象把日志输出到控制台。每个ConsoleAppender都有一个target�Q�表�C�它的输出目的地。它可以是System.out�Q�标准输��备（�~�冲昄��屏）�Q�或者是System.err�Q�标准错误设备（不缓冲显�C�屏�Q�。ConsoleAppender的��用方法参考如下API :.

------ Log4j APIs : class ConsoleAppender extends WriterAppender ------

// 构造方法，使用一个Layout对象构造一个ConsoleAppender对象 :.
// 默认情况下，ConsoleAppender的target是System.out :.

public ConsoleAppender(Layout layout);

// 构造方法，使用一个Layout对象和一个target字符串构造ConsoleAppender对象 :.
// target的可能取��gؓ(f��)ConsoleAppender.SYSTEM_OUT和ConsoleAppender.SYSTEM_ERR :.

public ConsoleAppender(Layout layout, String target);

FileAppender
可以使用FileAppender对象把日志输出到一个指定的日志文�g中去。��用方法可以参考如下的API :.

------ Log4j APIs : class FileAppender extends WriterAppender ------

// 构造方法，使用一个Layout对象和日志文件名构造一个FileAppender对象 :.

public FileAppender(Layout layout, String filename)
throws IOException;
public FileAppender(Layout layout, String filename, boolean append)
throws IOException;

RollingFileAppender
可以使用FileAppender的子�c�RollingFileAppender对象�Q�把日志输出��C��个指定的日志文�g中。不同的是该日志文�g的大��受到限�Ӟ��当日志内容超出最大的��寸�Ӟ��该文件将向上滚动�Q�最老的日志被擦除）。还可以在该�c�d��象中指定为日志文件做多少个备份。具体��用方法参考如下API :.

------ Log4j APIs : class RollingFileAppender extends FileAppender ------

// 构造方法，使用一个Layout对象和日志文件名构造一个RollingFileAppender对象 :.

public RollingFileAppender(Layout layout, String filename)
throws IOException;
public RollingFileAppender(Layout layout, String filename, boolean append)
throws IOException;

// 获得和设�|�日志备份文件的个数 :.

public int getMaxBackupIndex();
public void setMaxBackupIndex(int index);

// 获得和设�|�滚动日志文件的最大尺�?:.

public long getMaximumFileSize();
public void setMaximumFileSize(long size);

Layout�Q�日志格式化�?
每个appender都和一个layout相联�p�；layout的�Q务是格式化用��L(f��ng)��logging request�Q�appender的�Q务是把layout格式化好的输出内定w��往指定的目的地�?

PatternLayout
PatternLayout是Layout的一个子�c�，用来使用�c�M��C语言的printf函数中��用的格式控制字符串来控制日志的输出格式。��用方法参考如下API :.

------ Log4j APIs : class PatternLayout extends Layout ------

// 无参数构造方法，使用DEFAULT_CONVERSION_PATTERN构造一个PatternLayout :.
// 注意�Q�DEFAULT_CONVERSION_PATTERN�?%m%n"�Q�只打印消息信息 :.

public PatternLayout();

// 构造方法，使用自定义的pattern构造一个PatternLayout :.

public PatternLayout(String pattern);

// 获得和设�|�PatternLayout对象的日志pattern :.

public String getConversionPattern();
public void setConversionPattern(String pattern);

patterns in PatternLayout

Configuration�Q�配�|?
对log4j环境的配�|�就是对root logger的配�|�，包括把root logger讄��为哪个��?level)�Q��ؓ(f��)它增加哪些appender�Q�等�{�。这些可以通过讄��pȝ��属性的�Ҏ(gu��)��来隐式地完成�Q�也可以在程序里调用XXXConfigurator.configure()�Ҏ(gu��)��来显式地完成�?

默认的log4j初始化过�E?
Logger�cȝ��静态初始化�?static initialization block)中对log4j的环境做默认的初始化。注意：(x��)如果�E�序员已�l�通过讄��pȝ��属性的�Ҏ(gu��)��来配�|�了log4j环境�Q�则不需要再昑ּ�地调用XXXConfigurator.configure()�Ҏ(gu��)��来配�|�log4j环境了�?

Logger的静态初始化块在完成初始化过�E�时��检查一�p�d��log4j定义的系�l�属性。它所做的事情如下�Q?

��查系�l�属性log4j.defaultInitOverride�Q�如果该属性被讄��为false�Q�则执行初始化；否则�Q�只要不是false�Q�无论是什么��|��甚至没有��|��都是否则�Q�，跌��初始化�?
把系�l�属性log4j.configuration的��D��l�变量resource。如果该�pȝ��变量没有被定义，则把resource赋��gؓ(f��)"log4j.properties"。注意：(x��)在apache的log4j文档中徏议��用定义log4j.configuration�pȝ��属性的�Ҏ(gu��)��来设�|�默认的初始化文件是一个好�Ҏ(gu��)��?
试图把resource变量转化成�ؓ(f��)一个URL对象url。如果一般的转化�Ҏ(gu��)��行不通，��p��用org.apache.log4j.helpers.Loader.getResource(resource, Logger.class)�Ҏ(gu��)��来完成�{化�?
如果url�?.html"�l�尾�Q�则调用�Ҏ(gu��)��DOMConfigurator.configure(url)来完成初始化�Q�否则，则调用方法PropertyConfigurator.configure(url)来完成初始化。如果url指定的资源不能被获得�Q�则跛_��初始化过�E��?

BasicConfigurator.configure()
BasicConfigurator.configure()�Ҏ(gu��)��使用最��的方法配�|�log4j环境。注�Q�所谓配�|�log4j环境�Q�就是指配置root logger�Q�因为所有其它的logger都是root logger的后代，所以它们（默认情况下）都将�l�承root logger的性质�?br />
BasicConfigurator.configure()完成的�Q务是�Q?

用默认pattern创徏PatternLayout对象p�Q?
PatternLayout p = new PatternLayout("%-4r[%t]%-5p%c%x - %m%n");
用p创徏ConsoleAppender对象a�Q�目标是system.out�Q�标准输��备：(x��)
ConsoleAppender a = new ConsoleAppender(p,ConsoleAppender.SYSTEM_OUT);
为root logger增加一个ConsoleAppender p�Q?
rootLogger.addAppender(p);
把root logger的log level讄��为DEBUG�U�别�Q?
rootLogger.setLevel(Level.DEBUG);

xml格式的log4j配置文�g概述
xml格式的log4j配置文�g需要��用org.apache.log4j.html.DOMConfigurator.configure()�Ҏ(gu��)��来读入。对xml文�g的语法定义可以在log4j的发布包中找刎ͼ�(x��)org/apache/log4j/xml/log4j.dtd�?

log4j的xml配置文�g的树(w��i)状结�?
log4j的xml配置文�g的树(w��i)状结构如下所�C�，注意下图只显�C�Z��常用的部分�?:.

xml declaration and dtd
|
log4j:configuration
|
+-- appender (name, class)
| |
| +-- param (name, value)
| +-- layout (class)
| |
| +-- param (name, value)
+-- logger (name, additivity)
| |
| +-- level (class, value)
| | |
| | +-- param (name, value)
| +-- appender-ref (ref)
+-- root
|
+-- param (name, class)
+-- level
| |
| +-- param (name, value)
+-- appender-ref (ref)

xml declaration and dtd
xml配置文�g的头部包括两个部分：(x��)xml声明和dtd声明。头部的格式如下�Q?:.

log4j:configuration (root element)

xmlns:log4j [#FIXED attribute] : 定义log4j的名字空��_(d��)��取定�?http://jakarta.apache.org/log4j/"
appender [* child] : 一个appender子元素定义一个日志输出目的地
logger [* child] : 一个logger子元素定义一个日志写出器
root [? child] : root子元素定义了root logger

appender
appender元素定义一个日志输出目的地�?

name [#REQUIRED attribute] : 定义appender的名字，以便被后文引�?
class [#REQUIRED attribute] : 定义appender对象所属的�cȝ��全名
param [* child] : 创徏appender对象时传递给�c�L��造方法的参数
layout [? child] : 该appender使用的layout对象

layout
layout元素定义与某一个appender相联�pȝ��日志格式化器�?

class [#REQUIRED attribute] : 定义layout对象所属的�cȝ��全名
param [* child] : 创徏layout对象时传递给�c�L��造方法的参数

logger
logger元素定义一个日志输出器�?

name [#REQUIRED attribute] : 定义logger的名字，以便被后文引�?
additivity [#ENUM attribute] : 取��gؓ(f��)"true"�Q�默认）或�?false"�Q�是否��承父logger的属�?
level [? child] : 定义该logger的日志��?
appender-ref [* child] : 定义该logger的输出目的地

root
root元素定义�Ҏ(gu��)��志输出器root logger�?

param [* child] : 创徏root logger对象时传递给�c�L��造方法的参数
level [? child] : 定义root logger的日志��?
appender-ref [* child] : 定义root logger的输出目的地

level
level元素定义logger对象的日志��别�?

class [#IMPLIED attribute] : 定义level对象所属的�c�，默认情况下是"org.apache.log4j.Level�c?
value [#REQUIRED attribute] : 为level对象赋倹{��可能的取��g��到大依�ơ�ؓ(f��)"all"�?debug"�?info"�?warn"�?error"�?fatal"�?off"。当��gؓ(f��)"off"时表�C�没有�Q何日志信息被输出
param [* child] : 创徏level对象时传递给�c�L��造方法的参数

appender-ref
appender-ref元素引用一个appender元素的名字，为logger对象增加一个appender�?

ref [#REQUIRED attribute] : 一个appender元素的名字的引用
appender-ref元素没有子元�?

param
param元素在创建对象时为类的构造方法提供参数。它可以成�ؓ(f��)appender、layout、filter、errorHandler、level、categoryFactory和root�{�元素的子元素�?

name and value [#REQUIRED attributes] : 提供参数的一�l�名值对
param元素没有子元�?

在xml文�g中配�|�a(ch��n)ppender和layout
创徏不同的Appender对象或者不同的Layout对象要调用不同的构造方法。可以��用param子元素来讑֮�不同的参数倹{�?

创徏ConsoleAppender对象
ConsoleAppender的构造方法不接受其它的参数�?:.

... ... ... ...

... ...

... ... ... ...

创徏FileAppender对象
可以为FileAppender�cȝ��构造方法传递两个参敎ͼ�(x��)File表示日志文�g名；Append表示如文件已存在�Q�是否把日志�q�加到文件尾部，可能取��gؓ(f��)"true"�?false"�Q�默认）�?:.

... ... ... ...

... ...

... ... ... ...

创徏RollingFileAppender对象
除了File和Append以外�Q�还可以为RollingFileAppender�cȝ��构造方法传递两个参敎ͼ�(x��)MaxBackupIndex备䆾日志文�g的个敎ͼ�默认�?个）�Q�MaxFileSize表示日志文�g允许的最大字节数�Q�默认是10M�Q��?:.

... ... ... ...

... ...

... ... ... ...

创徏PatternLayout对象
可以为PatternLayout�cȝ��构造方法传递参数ConversionPattern�?:.

... ... ... ...

... ... ... ...

我自��q��一个��用xml文�g配置log4j环境的很��单的例子
为WSOTA��目开发java web start的胖客户端时�Q��用了如下的xml文�g配置log4j环境�Q�文件名为wsota-rc.log4j.html�Q�：(x��):.

在胖客户�E�序中��用了如下代码来��用外部xml文�g配置log4j环境�Q�注意该代码�D�位于程序的main class的静态初始化块中�Q�含有以下代码的�c�d��xml配置文�g在同一个目录下�Q?.

import org.apache.log4j.html.DOMConfigurator;

public class SapFrame extends JFrame {
static {
DOMConfigurator.configure(SapFrame.class.getResource("wsota-rc.log4j.html"));
}
... ... ... ...
}

Log4j的编码习(f��n)�?

让每个类都拥有一个private static的Logger对象�Q�用来输��c�M��的全部日志信�?
使用xml文�g来完成对log4j环境的配�|�。在��目的main class中的静态初始化块里放log4j环境的配�|�代码。注意：(x��)在一个项目中�Q�log4j环境只需要被配置一�ơ，而不是在每个使用了logger的类里都需要调用一��?
用MyClass.class作�ؓ(f��)参数创徏该类的静态Logger对象
补充�?..

from: http://zooo.51.net/heavyz_cs/notebook/log4j.html

zeroone0 2006-04-06 23:26 发表评论

zeroone0 — Thu, 06 Apr 2006 15:18:00 GMT
Log4j��明手�?br />
1. 概述
本文主要描述Log4j的API的唯一�Ҏ(gu��)��和它的设计原理。Log4j是一个基于许多作者的开放源码的��目。它允许开发员以�Q意的间隔来控制日志的输出。它通过讑֜�外部的配�|�文件而达到运行时灉|��的设�|�。最重要的是�Q�Log4j有一个��^�E�的学习(f��n)曲线。注意：(x��)�Ҏ(gu��)��来自用户的反馈判断，它很�Ҏ(gu��)��使�h上瘾�?br />
2. ��D��

几乎所有的大型应用�E�序都包括它的自��q��日志和跟�t�API。顺应这个规则，E.U. SEMPER ��目军_��写它自己的跟�t�PAI。这�?996�q�初。在无数�ơ加强，几次变�Ş和许多工作后�Q�那个API变成了如今的Log4j�Q�一个流行的java日志包。这个包以Apache Software License协议发布�Q�一个成熟的开放源吗协议。最新的Log4j版本�Q�包括全部的源码�Q�class文�g和文档，你可以在http://jakarta.apache.org/Log4j/上找到。顺便，Log4j已经�l�C(j��), C++, C#, Python, Ruby, and Eiffel 语言都提供了接口�?br />
��Z��调试而插入日志输出到代码里是一个低技术成分的�Ҏ(gu��)��Q�但它可能也是唯一的方法，因�ؓ(f��)调试器�ƈ不是一直可用或者可以适应的，��其对于多线�E�的分布使式的大型程序而言�?br />
�l�验指出调试是��Y件开发周期中一个重要的�l�成部分�?br />
Log4j拥有几个优点�Q?br />
首先�Q�它提供关于�q�行�E�序的准��的环境。一旦代码被插入�Q�不需要�h工干预就可以产生调试信息�?br />
其次�Q�日志输出可以被有计划的保存在永久媒体中以便日后研究�?br />
另外�Q�除了在开发周期中�Q�一个充分详��的日志包可以被用来作�ؓ(f��)以后的统计工兗��?br />
Log4j当然�q�有它的�~�点�Q�它可能减慢�E�序。如果太详细�Q�它可能��D��屏幕盲目滚动。排除这些情况，Log4j是可靠的�Q�快速的�Q�可以扩展的。因为日志很��是一个应用程序的主要目的, 设计者们正努力��得Log4j API学习(f��n)和��用简单化�?br />
3. 日志�c�d��、输出源和布局

Log4j有三个主要的�l��g�Q�日志类别（Loggers�Q�、输出源�Q?Appenders�Q�和布局�Q�Layouts�Q�。这三种�c�d��的组件一起工作��得开发员可以�Ҏ(gu��)��信息的类型和�U�别记录它们�Q��ƈ且在�q�行时控制这些信息的输出格式和位�|��?br />
3.1 日志�c�d��的层�ơ结�?Loggers)

Log4j首要的相对于��单的使用System.out.println()�Ҏ(gu��)��的优�Ҏ(gu��)��Z��它的在禁止一些特定的信息输出的同时不妨碍其它信息的输出的能力。这个能力源自于日志命名�I�间�Q�也��是��_(d��)��所有日志声明的�I�间�Q�它�Ҏ(gu��)��一些开发员选择的公式而分�c�R��以前的观察引导我们选择�c�d��作�ؓ(f��)包的中心概念。然而，自从Log4j�?.2版本�Q�Logger�c�被Catalog�c�L��取代�Q�对于那些熟�(zh��n)�Log4j以前版本的�h来说�Q�Logger�c�d��以被惌��成仅仅是Category �cȝ��别名�?br />
Loggers 被指定�ؓ(f��)实体�Q�Logger的名字是大小写敏感的�Q�它们遵循以下的命名

规则�Q?br />
2 命名�l�承

如果�c�d��的名�U�ͼ�后面加一个点�Q�是其子�c�d��名称的前�~��Q�则它就是另一个类别的��辈�?br />
如果一个类�?Logger)和它的子�c�d��之间没有其它的��承关�p�，我们��q��之�ؓ(f��)parent与child的关�p�R�?br />
例如�Q�类�?com.foo"是类�?com.foo.Bar"的parent。相似的�Q?java"�?java.util"的parent�Q�是"java.util.Vector"的父辈�?�q�个命名规则应该被大多数的开发员所熟�?zh��n)��?br />
�?root) �c�d��位于logger�l�承�l�构的最上层。它有两�U�例外：(x��)

1.它一直存�?br />
2.它不能根据名�U�而获得�?

调用�cȝ��静态方法Logger.getRootLogger可以得到它。其它所有的Logger可以通过静态方法Logger.getLogger而得到它们自��q��实例。这个方法取希望的Logger名作为参数。Logger的一些基本的�Ҏ(gu��)��C�Z��如下�Q?br />
package org.apache.Log4j;

public Logger class {

// Creation & retrieval methods:

public static Logger getRootLogger();

public static Logger getLogger(String name);

// printing methods:

public void debug(Object message);

public void info(Object message);

public void warn(Object message);

public void error(Object message);

// generic printing method:

public void log(Level l, Object message);

}

Loggers可以被分配的�U�别。所有��别的集合包括�Q?br />
DEBUG

INFO

WARN

ERROR

FATAL

它们被定义于org.apache.Log4j.Level �c�R��虽然我们不鼓励�Q�但是你们可以通过�l�承Level�c�L��定义你们自己的��别。我们随后将介绍一个比较好的方法�?br />
如果一个Logger没有被分配一个��别，那么它将从一个被分配了��别的最接近它的ancestor哪里�l�承�?br />
正规的说�Q?br />
2 �U�别�l�承

对于一个给定的Logger C�Q�它的��承的�U�别�{�于从C开始上溯到的第一个拥有非�I��别的Logger的��别�?br />
��Z��保证所有的Logger最�l�能够��承到一个��别，根Logger通常有一个已�l�定义了的��别�?br />
以下四个表中的数据演�C�Z��Ҏ(gu��)��以上规则得到的结果�?br />
�c�d��?br />分配的��?br />�l�承的��?br />
root
Proot
Proot

X
none
Proot

X.Y
none
Proot

X.Y.Z
none
Proot

Example 1

在例�?中，只有根Logger定义了一个��别，它的�U�别的�?-"Proot"被所有其它的Loggers X, X.Y, 和X.Y.Z所�l�承�?br />
�c�d��?br />分配的��?br />�l�承的��?br />
root
Proot
Proot

X
Px
Px

X.Y
Pxy
Pxy

X.Y.Z
Pxyz
Pxyz

Example 2

在例�?中，所有的Logger都有一个被分配的��别��|��所以它们不需要��别��ѝ�?br />
�c�d��?br />分配的��?br />�l�承的��?br />
root
Proot
Proot

X
Px
Px

X.Y
none
Px

X.Y.Z
Pxyz
Pxyz

Example 3

在例�?中，根Logger�Q�以�?qi��ng)X和X.Y.Z被分别分配了�U�别Proot�Q�Px和Pxyz。Logger X.Y从它的parent X�l�承了��别值Px�?br />
�c�d��?br />分配的��?br />�l�承的��?br />
root
Proot
Proot

X
Px
Px

X.Y
none
Px

X.Y.Z
none
Px

Example 4

在例�?中，根Logger和X被分别分配了�U�别"Proot"�?Px"�Q�Logger X.Y �?X.Y.Z从被分配了��别的最接近它们的ancestor X那里得到�l�承�?br />
我们需要通过调用Logger的输出的实例�Ҏ(gu��)��之一来实现日志请求。这些输出的�Ҏ(gu��)��是debug, info, warn, error, fatal �?log.

通过定义输出�Ҏ(gu��)��来区分日志的��h��的��别。例如，如果c是一个Logger的实例，那么声明 c.info ��是一个INFO�U�别的日志请求�?br />
如果一个日志的��h��的��别高于或�{�于日志的��别那么它?y��u)��p��被启用。反之，��被��用。一个没有被安排�U�别的Logger��从它的父辈中得到��ѝ��这个规则�ȝ��如下�?br />
2 基本的选择规则

假如在一个��别�ؓ(f��)q的Logger中发生一个��别�ؓ(f��)p的日志请求，如果p>=q,那么��h��被启用�?br />
�q�是Log4j的核心原则。它假设�U�别是有序的。对于标准��别，我们定义DEBUG < INFO < WARN < ERROR < FATAL.

以下是关于这条规则的一个例子�?br />
// get a logger instance named "com.foo"

Logger logger = Logger.getLogger("com.foo");

// Now set its level. Normally you do not need to set the

// level of a logger progamitcally. This is usually done

// in configuration files.

cat.setLevel(Level.INFO);

Logger barlogger = Logger.getLogger("com.foo.Bar");

// This request is enabled, because WARN >= INFO.

logger.warn("Low fuel level.");

// This request is disabled, because DEBUG < INFO.

logger.debug("Starting search for nearest gas station.");

// The logger instance barlogger, named "com.foo.Bar",

// will inherit its level from the logger named

// "com.foo" Thus, the following request is enabled

// because INFO >= INFO.

barlogger.info("Located nearest gas station.");

// This request is disabled, because DEBUG < INFO.

barlogger.debug("Exiting gas station search");

调用getLogger�Ҏ(gu��)��返回一个同名的Logger对象的实例�?br />
例如�Q?br />
Categoty x = Logger.getLogger("wombat");

Categoty y = Logger.getLogger("wombat");

x和y参照的是同一个Logger对象�?br />
�q�样我们��可以先定义一个Logger�Q�然后在代码的其它地方不需传参��可以重新得到我们已�l�定义了的Logger的实�?

同基本的生物学理�?-父先于子相反�Q�Log4j 的loggers可以以�Q何顺序创造和配置。特别是�Q�一个后实例化的"parent"logger能够扑ֈ��q�且�q�接它的子logger�?br />
配置Log4j的环境通常在一个应用程序被初始化的时候进行，最好的�Ҏ(gu��)��是通过��M��个配�|�文件。这个方法我们将��短介�l��?br />
Log4j使得通过软�g�l��g命名logger很容易。我们可以通过Logger的静态的初始化方法在每一个类里定义一个logger�Q��o(h��)logger的名字等于类名的全局名，而实现l(f��)ogger的命名。这是一个实效的��单的定义一个logger的方法。因为日志输出带有��生日志的�cȝ��名字�Q�这个命名策略��得我们更�Ҏ(gu��)��定位��C��个日志信息的来源。虽然普通，但却是命名logger的常用策略之一。Log4j没有限制定义logger的可能。开发员可以自由的按照它们的意愿定义logger的名�U��?br />
然而，以类的所在位�|�来命名Logger好象是目前已知的最好方法�?br />
3.2 输出源（Appenders�Q�和布局�Q�Layouts�Q?br />
有选择的能用或者禁用日志请求仅仅是Log4j的一部分功能。Log4j允许日志��h��被输出到多个输出源。用Log4j的话��_(d��)��一个输出源被称做一个Appender. 。Appender包括console�Q�控制台�Q? files�Q�文�Ӟ��, GUI components�Q�图形的�l��g�Q? remote socket servers�Q�socket 服务�Q? JMS�Q�java信息服务�Q? NT Event Loggers�Q�NT的事件日志）, and remote UNIX Syslog daemons�Q�远�E�UNIX的后台日志服务）。它也可以做到异步记录�?br />
一个logger可以讄��过一个的appender�?br />
用addAppender �Ҏ(gu��)��d��一个appender��C��个给定的logger。对于一个给定的logger它每个生效的日志��h��都被转发到该logger所有的appender上和该logger的父辈logger的appender上。换句话��_(d��)��appender自动从它的父辈获得��ѝ��D例来��_(d��)��如果一个根logger拥有一个console appender�Q�那么所有生效的日志��h��臛_��?x��)被输出到console上。如果一个名为C的logger有一个file�c�d��的appender�Q�那么它?y��u)�׃�?x��)对它自己以及(qi��ng)所有它的子logger生效。我们也可以通过讄��a(ch��n)ppender的additivity flag 为false�Q�来重蝲appender的默认行为，以便�l�承的属性不在生效�?br />
调节输出源（appender�Q�添加性的规则如下�?br />
输出源的可添加性（Appender Additivity �Q?br />
一个名为C的logger的日志定义的输出��g�l�到它自�w�以�?qi��ng)它的ancestor logger的appenders。这��是术语"appender additivity"的含义�?

然而，logger C的一个ancestor logger P�Q�它的附加标志被设�ؓ(f��)false�Q�那么C的输出将被定位到所有C的appender�Q�以�?qi��ng)从它开始上溯到P的所有ancestor logger的appender�?br />
Loggers的附加标讎ͼ�additivity flag�Q�默认�ؓ(f��)true�?br />
下表是一个例子�?br />
Logger
Name
Added
Appenders
Additivity
Flag
Output Targets
Comment

root
A1
not applicable
A1
The root logger is anonymous but can be accessed with the Logger.getRootLogger() method. There is no default appender attached to root.

x
A-x1, A-x2
true
A1, A-x1, A-x2
Appenders of "x" and root.

x.y
none
true
A1, A-x1, A-x2
Appenders of "x" and root.

x.y.z
A-xyz1
true
A1, A-x1, A-x2, A-xyz1
Appenders in "x.y.z", "x" and root.

security
A-sec
false
A-sec
No appender accumulation since the additivity flag is set to false.

security.access
none
true
A-sec
Only appenders of "security" because the additivity flag in "security" is set to false.

�l�常�Q�用户希望自定义不但输出源，而且定义输出格式。这个是通过在一个appender上附加一个layout来完成的。layout是负责根据用��L(f��ng)��希望来格式化日志��h��。而appender是负责发送格式化的输出到它的目的地。PatternLayout�Q�作为Log4j标准版中的一部分�Q�让用户指以�c�M��C语言的printf�Ҏ(gu��)��的格式来指定日志的输出格式�?br />
例如�Q��{化模式�ؓ(f��)"%r [%t] %-5p %c - %m%n" 的PatternLayout ��输出类似如下的信息�Q?br />
176 [main] INFO org.foo.Bar - Located nearest gas station.

�W�一个栏位是自从�E�序开始后消逝的毫秒数�?br />
�W�二个栏位是做出日志的线�E��?br />
�W�三个栏位是log的��别�?br />
�W�四个栏位是日志��h��相关的logger的名字。�?-"后的文字是信息的表述�?br />
Log4j��根据用户定义的公式来修饰日志信息的内容。例如，如果你经帔R��要记录Oranges�Q�一个在你当前的��目被用到的对象�c�d��Q�那么你可以注册一个OrangeRenderer �Q�它?y��u)��在一个orange需要被记录时被调用�?br />
对象渲染�c�M��的类的结构��ѝ��例如，假设oranges是fruits�Q�如果你注册了一个FruitRenderer�Q�所有的水果包括oranges��被FruitRenderer所渲染。除非你注册了一个orange�?br />
对象渲染必须实现ObjectRenderer接口�?br />
4. 配置

插入日志��h��到应用程序的代码中需要大量的预先计划和最�l�努力。观察显�C�大�U?%的代码是用来输出的�?br />
因此�Q�大��适度的程序都被嵌入有成千个日志输��句。�ؓ(f��)了以无需手工的方式管理这些日志的输出状态，�l�日志输��Z��~�号和规范变得势在必行�?

Log4j在程序中有充分的可配�|�性。然而，用配�|�文仉��|�Log4j��h��更大的弹性。目前，它的配置文�g支持xml和java properties�Q�key=value�Q�文件两�U�格式�?br />
让我们以一个例子来演示它是如何做的。假定有一个用了Log4j的程序MyApp�?br />

import com.foo.Bar;

// Import Log4j classes.

import org.apache.Log4j.Logger;

import org.apache.Log4j.BasicConfigurator;

public class MyApp {

// Define a static logger variable so that it references the

// Logger instance named "MyApp".

static Logger logger = Logger.getLogger(MyApp.class);

public static void main(String[] args) {

// Set up a simple configuration that logs on the console.

BasicConfigurator.configure();

logger.info("Entering application.");

Bar bar = new Bar();

bar.doIt();

logger.info("Exiting application.");

}

}

MyApp以引入Log4j的相关类开始，接着它定义了一个静态logger变量�Q��ƈ�l�予��gؓ(f��)"MyApp"�cȝ��全�\径名�U��?br />
MYApp用了定义在包com.foo中的�c�Bar.

package com.foo;

import org.apache.Log4j.Logger;

public class Bar {

static Logger logger = Logger.getLogger(Bar.class);

public void doIt() {

logger.debug("Did it again!");

}

}

调用BasicConfigurator.configure()�Ҏ(gu��)��创徏了一个相当简单的Log4j的设�|�。它加入一

个ConsoleAppender到根logger。输出将被采用了"%-4r [%t] %-5p %c %x - %m%n"模式

的PatternLayout所格式化�?br />
注意�Q�根logger默认被分配了Level.DEBUG的��别�?br />
MyApp的输��Zؓ(f��)�Q?br />
0 [main] INFO MyApp - Entering application.

36 [main] DEBUG com.foo.Bar - Did it again!

51 [main] INFO MyApp - Exiting application.

随后的图形描�q�C��在调用BasicConfigurator.configure()�Ҏ(gu��)��后MyApp的对象图�?br />

一边要提醒的是�Q�Log4j的子logger只连接到已经存在的它们的父代。特别的是，名�ؓ(f��)

com.foo.bar的logger是直接连接到根logger�Q�而不是围�l�着没用的com或com.foo

logger。这显著的提高了�E�序性能�q�且减少的内存占用�?br />
MyApp�c�配�|�Log4j是通过调用BasicConfigurator.configure �Ҏ(gu��)��。其它的�c�M��?br />
需要引入org.apache.Log4j.Logger �c�，扑ֈ�它们希望用的logger�Q��ƈ且用它就行�?br />
以前的例子通常输出同样的日志信息。幸�q�的是，修改MyApp是容易的�Q�以便日志输

出可以在�q�行时刻被控制。这里是一个小��修改的版本�?br />

import com.foo.Bar;

import org.apache.Log4j.Logger;

import org.apache.Log4j.PropertyConfigurator;

public class MyApp {

static Logger logger = Logger.getLogger(MyApp.class.getName());

public static void main(String[] args) {

// BasicConfigurator replaced with PropertyConfigurator.

PropertyConfigurator.configure(args[0]);

logger.info("Entering application.");

Bar bar = new Bar();

bar.doIt();

logger.info("Exiting application.");

}

}

修改后的 MyApp通知�E�序调用PropertyConfigurator()�Ҏ(gu��)��解析一个配�|�文�Ӟ��q�且�?br />
据这个配�|�文件来讄��日志�?br />
�q�里是一个配�|�文件的例子�Q�它?y��u)��生同以前BasicConfigurator 基本例子一�?br />
的输出结果�?br />
# Set root logger level to DEBUG and its only appender to A1.

Log4j.rootLogger=DEBUG, A1

# A1 is set to be a ConsoleAppender.

Log4j.appender.A1=org.apache.Log4j.ConsoleAppender

# A1 uses PatternLayout.

Log4j.appender.A1.layout=org.apache.Log4j.PatternLayout

Log4j.appender.A1.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n

假设我们不在对com.foo包的��M��cȝ��输出感兴��的话，随后的配�|�文件向我们展示

了实现这个目的的�Ҏ(gu��)��之一�?br />
Log4j.rootLogger=DEBUG, A1

Log4j.appender.A1=org.apache.Log4j.ConsoleAppender

Log4j.appender.A1.layout=org.apache.Log4j.PatternLayout

# Print the date in ISO 8601 format

Log4j.appender.A1.layout.ConversionPattern=%d [%t] %-5p %c - %m%n

# Print only messages of level WARN or above in the package com.foo.

Log4j.logger.com.foo=WARN

以这个配�|�文仉��|�好的MyApp��输出如下：(x��)

2000-09-07 14:07:41,508 [main] INFO MyApp - Entering application.

2000-09-07 14:07:41,529 [main] INFO MyApp - Exiting application.

当logger com.foo.bar没有被分配一个��别，它将从com.foo�l�承�Q�在配置文�g�?br />
它被讄��了WARN的��别。在Bar.doIt�Ҏ(gu��)��中定义的log为DEBUG�U�别�Q�低于WARN�Q?br />
因此doIt() �Ҏ(gu��)��的日志请求被��用�?br />
�q�里是另外一个配�|�文�Ӟ��它��用了多个appenders.

Log4j.rootLogger=debug, stdout, R

Log4j.appender.stdout=org.apache.Log4j.ConsoleAppender

Log4j.appender.stdout.layout=org.apache.Log4j.PatternLayout

# Pattern to output the caller´s file name and line number.

Log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F:%L) - %m%n

Log4j.appender.R=org.apache.Log4j.RollingFileAppender

Log4j.appender.R.File=example.log

Log4j.appender.R.MaxFileSize=100KB

# Keep one backup file

Log4j.appender.R.MaxBackupIndex=1

Log4j.appender.R.layout=org.apache.Log4j.PatternLayout

Log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n

以这个配�|�文件调用加��Z��的MyApp�c�d��输出如下信息.

INFO [main] (MyApp2.java:12) - Entering application.

DEBUG [main] (Bar.java:8) - Doing it again!

INFO [main] (MyApp2.java:15) - Exiting application.

另外,因�ؓ(f��)根logger有被分配�W�二个appender,所以输��Z��被定向到example.log文�g�?br />
�q�个文�g大小辑ֈ�100kb时将自动备䆾。备份时老版本的example.log文�g自动被移�?br />
文�gexample.log.1中�?br />
注意我们不需要重新编译代码就可以获得�q�些不同的日志行为。我们一样可以容�?br />
的��日志输出到UNIX Syslog daemon, 重定向所有的com.foo到NT Event logger,

或者�{发日志到一个远�E�的Log4j服务�?它根据本地server的策略来�q�行日志输出。例

如�{发日志事件到�W�二个Log4j服务�?

5. 默认的初始化�q�程
Log4j�c�d��不对它的环境做�Q何假设。特别是没有默认的Log4j appender。在一些特�?br />
的有着良好定义的环境下�Q�logger的静态inializer��尝试自动的配置Log4j�?br />
java语言的特性保证类的静态initializer当且仅当装蝲�c�d��内存之时只会(x��)被调用一�ơ�?br />
要记住的重要一�Ҏ(gu��)��Q�不同的�c�装载器可能装蝲同一个类的完全不同的拯��?br />
�q�些同样�cȝ��拯��被虚拟机认�ؓ(f��)是完全不相干的�?br />
默认的initialization是非常有用的�Q�特别是在一些应用程序所依靠的运行环境被准确�?br />
定位的情况下。例如，同一��L(f��ng)��应用�E�序可以被用做一个标准的应用�E�序�Q�或一�?br />
applet�Q�或一个在web-server控制下的servlet�?br />
准确的默认的initialization原理被定义如下：(x��)

1.讄��pȝ��属性Log4j.defaultInitOverride�?false"以外的其它��|��那么Log4j��?br />
跌��默认的initialization�q�程�?br />
2.讄��资源变量字符串给�pȝ��属性Log4j.configuration。定义默认initialization

文�g的最好的�Ҏ(gu��)��是通过�pȝ��属性Log4j.configuration。万一�pȝ��属�?br />
Log4j.configuration没有被定义，那么讄��字符串变量resource �l�它的默认�?br />
Log4j.properties�?br />
3.��试转换resource 变量��Z��个URL�?br />
4.如果变量resource的��g��能被转换��Z��个URL�Q�例如由于MalformedURLException�q?br />
例，那么通过调用

org.apache.Log4j.helpers.Loader.getResource(resource, Logger.class) �Ҏ(gu��)��?br />
classpath中搜索resource�Q�它?y��u)��返回一个URL�Q��ƈ通知"Log4j.properties"的值是一个错

误的URL�?br />
看See Loader.getResource(java.lang.String) 查看搜烦位置的列表�?br />
5.如果没有URL被发玎ͼ�那么攑ּ�默认的initialization。否则用URL配置Log4j�?br />
PropertyConfigurator��用来解析URL�Q�配�|�Log4j�Q�除非URL�?.xml"为结��?br />
在这�U�情况下的话DOMConfigurator��被调用。你可以有机�?x��)定义一个自定义�?br />
configurator�?br />
�pȝ��属性Log4j.configuratorClass 的值取自你的自定义的类名的全�\径�?br />
你自定义的configurator必须实现configurator接口�?br />

6. 配置范例
6.1 Tomcat下的初始�?br />默认的Log4j initialization典型的应用是在web-server 环境下。在tomcat3.x和tomcat4.x

下，你应该将配置文�gLog4j.properties攑֜�你的web应用�E�序的WEB-INF/classes 目录

下�?br />
Log4j��发现属性文�Ӟ��q�且以此初始化。这是��它工作的最�Ҏ(gu��)��的方法�?br />
你也可以选择在运行tomcat前设�|�系�l�属性Log4j.configuration 。对于tomcat 3.x�Q?br />
TOMCAT_OPTS �pȝ��变量是用来设�|�命令行的选项。对于tomcat4.0�Q�用�pȝ��环境�?br />
量CATALINA_OPTS 代替了TOMCAT_OPTS�?br />
Example 1

UNIX 命��o(h��)�?br />
export TOMCAT_OPTS="-DLog4j.configuration=foobar.txt"

告诉Log4j用文件foobar.txt作�ؓ(f��)默认的配�|�文件。这个文件应该放在WEB-INF/classes

目录下。这个文件将被PropertyConfigurator所诅R��每个web-application��用不同的默�?br />
配置文�g�Q�因为每个文件是和它的web-application 相关的�?br />
Example 2

UNIX 命��o(h��)�?br />
export TOMCAT_OPTS="-DLog4j.debug -DLog4j.configuration=foobar.xml"

告诉Log4j输出Log4j-internal的调试信息，�q�且用foobar.xml作�ؓ(f��)默认的配�|�文件�?br />
�q�个文�g应该攑֜�你的web-application的WEB-INF/classes 目录下。因为有.xml�?br />
扩展名，它将被DOMConfigurator所诅R��每个web-application��用不同的默�?br />
配置文�g。因为每个文仉��和它所在的web-application 相关的�?br />
Example 3

UNIX 命��o(h��)�?br />
set TOMCAT_OPTS=-DLog4j.configuration=foobar.lcf -DLog4j.configuratorClass=com.foo.BarConfigurator

告诉Log4j用文件foobar.lcf作�ؓ(f��)默认的配�|�文件。这个文件应该放在你�?br />
web-application的WEB-INF/classes 目录下。因为定义了Log4j.configuratorClass �pȝ��?br />
性，文�g��用自定义的com.foo.barconfigurator�c�L��解析。每个web-application��用�?br />
同的默认配置文�g。因为每个文仉��和它所在的web-application 相关的�?br />
Example 4

UNIX 命��o(h��)�?br />
set TOMCAT_OPTS=-DLog4j.configuration=file:/c:/foobar.lcf

告诉Log4j用文件foobar.lcf作�ؓ(f��)默认的配�|�文件。这个配�|�文件用URL file:/c:/foobar.lcf

定义了全路径名。这样同��L(f��ng)��配置文�g��被所有的web-application所用�?br />
不同的web-application��通过它们自己的类装蝲器来装蝲Log4j。这��P��每个Log4j的环

境将独立的运作，而没有�Q何的�怺�同步。例如：(x��)在多个web-application中定义了

完全相同的输出源的FileAppenders��尝试写同样的文件。结果好象是�~�Z��安全性的�?br />
你必��ȝ��保每个不同的web-application的Log4j配置没有用到同样的系�l�资源�?br />

6.2 Servlet 的初始化
用一个特别的servlet来做Log4j的初始化也是可以的。如下是一个例子：(x��)

package com.foo;

import org.apache.Log4j.PropertyConfigurator;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.io.PrintWriter;

import java.io.IOException;

public class Log4jInit extends HttpServlet {

public void init() {

String prefix = getServletContext().getRealPath("/");

String file = getInitParameter("Log4j-init-file");

// if the Log4j-init-file is not set, then no point in trying

if(file != null) {

PropertyConfigurator.configure(prefix+file);

}

}

public void doGet(HttpServletRequest req, HttpServletResponse res) {

}

}

在web.xml中定义随后的servlet��Z��的web-application�?br />

Log4j-init

com.foo.Log4jInit

Log4j-init-file

WEB-INF/classes/Log4j.lcf

1

写一个初始化的servlet是最有弹性的初始化Log4j的方法。代码中没有��M��限制�Q�你�?br />
以在servlet的init�Ҏ(gu��)��中定义它�?br />
7. Nested Diagnostic Contexts

在现实世界中的系�l�经�怸�得不同时处理多个客户端请求。在�q�样的一个典型的多线�E�的�pȝ��中，不同的线�E�将处理不同的客��L(f��ng)��。Logging特别能够适应�q�种复杂的分布式的应用程序的调试和跟�t�。一个常见的区分每个客户端所输出的Logging的方法是为每个客��L(f��ng)��实例化一个新的独立的Logger。这��D��Logger的大量��生，��理的成本也��过了logging本��n�?

唯一标识每个log��h��是一个轻量��的技术。Neil Harrison 在名为“Patterns for Logging Diagnostic Messages”的书中描述了这个方法in Pattern Languages of Program Design 3, edited by R. Martin, D. Riehle, and F. Buschmann (Addison-Wesley, 1997).

��Z��唯一标识每个��h��Q�用��h��上下文信息推入NDC(Nested Diagnostic Context)中�?br />
NDC�cȝ��例如下：(x��)

public class NDC {

// Used when printing the diagnostic

public static String get();

// Remove the top of the context from the NDC.

public static String pop();

// Add diagnostic context for the current thread.

public static void push(String message);

// Remove the diagnostic context for this thread.

public static void remove();

}

NDC如同一个堆栈样��理每个�U�程。注意所有the org.apache.log4j.NDC �cȝ��Ҏ(gu��)��都是静态的。假设NDC输出被开启，每次一个log ��h��被生成时�Q�适当的log4j�l��g为将要输出log的线�E�包含完整的NDC堆栈。这是在没有用户的干预的情况下做到的�Q�用户只负责在NDC中定位正��的信息�Q�通过在代码中正确位置插入很少的push和pop�Ҏ(gu��)��p��了。相反的�Q�在代码中per-client实现�Ҏ(gu��)��有着很大变化�?br />
��Z��演示�q�个点，让我们以一个发送内容到匿名客户端的servlet��Z��。这个servlet可以在开始执行每个其他代码前的初始化时徏立NDC。上下文信息可以是客户主机的名字和其他的��h��中固有的信息�?br />
典型的信息包括cookies。因此，即��servlet同时为多个客户同时提供服务，log 被同��L(f��ng)��代码初始化，例如属于同一个logger�Q�依然可以被区别�Q�因为每个客戯��求将有不同的NDC堆栈。与之相比，Contrast this with the complexity of passing a freshly instantiated logger to all code exercised during the client´s request�?br />
不过�Q�一些诡异的�E�序�Q�例如虚拟主机的web server记录日志�Q�不是一般的依靠虚拟��L��的上下文�Q�还要依靠��Y件的�l��g发出��h��。近来log4j的发布版本支持多层的�?w��i)�Ş�l�构。这个增强允许每个虚拟主机可以处理在�?w��i)型�l�构中属于它自己的logger�?br />
8. 优化
一个经常引用的依靠于logging的参数是可以计算的花贏V��这是一个合理的概念�Q�一个适度的应用程序可能��生成千上万个日志��h��。许多努力花在测量和调试logging的优化上。Log4j要求快速和�Ҏ(gu��)��：(x��)速度最重要�Q�弹性是其次�?br />
用户应该注意随后的优化徏议�?br />
1.日志为禁用时�Q�日志的优化�?br />
当日志被��d��的关闭，一个日志请求的��p��{�于一个方法的调用加上整数的比较时间�?br />
�?33mhz的Pentium II 机器上这个花贚w��常�?-50�U�秒之间�?br />
然而，�Ҏ(gu��)��调用包括参数构徏的隐藏花贏V�?br />
例如�Q�对于logger cat�Q?br />
logger.debug("Entry number: " + i + " is " + String.valueOf(entry[i]));

引�v了构��Z��息参数的��p��Q�例如，转化整数i和entry[i]��C��个string�Q��ƈ且连接中间字�W�串�Q�不��信息是否被输出。这个参数的构徏��p��可能是很高，它主要决定于被调用的参数的大��?br />
避免参数构徏的花费应如下�Q?br />
if(logger.isDebugEnabled() {

logger.debug("Entry number: " + i + " is " + String.valueOf(entry[i]));

}

如果logger的debug被关闭这��不�?x��)招致参数构建的��p��。另一斚w��Q�如果logger是debug的话�Q�它?y��u)��生两�ơ判�?logger是否能用的花贏V��一�ơ是在debugenabled�Q�一�ơ是debug。这是无关紧要的�Q�因为判断日志的能用只占日志实际��p��旉��的约1%�?br />
在Log4j里，日志��h��在Logger �cȝ��实例里。Logger 是一个类�Q�而不是一个接口。这大量的减��了在方法调用上的弹性化的花贏V�?br />
当然用户采用预处理或�~�译旉��技术去�~�译出所有的日志声明。这��导致完��的执行成效。然而因��Z��q�制应用�E�序不包括�Q何的日志声明的结果，日志不可能对那个二进制程序开启。以我的观点�Q�以�q�种较大的代��h��换取较小的性能优化是不值得的�?br />
2。当日志状态�ؓ(f��)启用�Ӟ��日志的优化�?br />
�q�是本质上的优化logger的层�ơ。当日志状态�ؓ(f��)开�Q�Log4j依然需要比较请求的�U�别与logger的��别。然而， logger可能没有被安排一个��别；它们��从它们的father�l�承。这��P��在��承之前，logger可能需要搜索它的ancestor�?br />
�q�里有一个认真的努力使层�ơ的搜烦��可能的快。例如，子logger仅仅�q�接到它的存在的father logger�?br />
在先前展�C�的BasicConfigurator 例子中，名�ؓ(f��)com.foo.bar 的logger是连接到跟根logger�Q�因此绕�q?了不存在的logger com和com.foo。这��显著的改善执行的速度�Q�特别是解析logger的层�l�构时�?br />
典型的层�ơ结构的解析的花�Ҏ(gu��)��logger��d��关闭时的三倍�?br />
3.日志信息的输出时�Q�日志的优化�?br />
�q�是主要��p��在日志输出的格式化和发送它到它的输出源上。这里我们再一�ơ的付出努力以��格式化执行的��可能快。同appender一栗��实际上典型的花费大�U�是100-300毫秒�?br />
详情看org.apache.log4.performance.Logging�?br />
虽然Log4j有许多特点，但是它的�W�一个设计目标还是速度。一些Log4j的组件已�l�被重写�q�很多次以改善性能。不�q�，投稿者经常提��Z��新的优化。你应该满意的知道，以SimpleLayout的配�|�执行测试已�l�展�C�Z��Log4j的输出同System.out.println一样快�?br />
9. �ȝ��
Log4j是一个用java写成的流行的日志包。一个它与众不同的特�Ҏ(gu��)��在logger中的�l�承的概��c��用logger的��承可以以��L��的间隔控制日志的状态输出。这个减��了体积和最��化日志的代仗��?br />
易管理性是Log4j API的优点之一。只要日志定义被加入��C��码中�Q�它们就可以用配�|�文件来控制。它们可以有选择的被��用�Q��ƈ且发送到不同的多个输出源上，以用户选择好的格式�?br />
Log4j的包被设计成�Q�不需��p��沉重的执行代价就可以保留它们在��品中�?br />

zeroone0 2006-04-06 23:18 发表评论

java 1.5

zeroone0 — Tue, 04 Apr 2006 23:51:00 GMT

增强的for循环
　　��Z��q�代集合和数�l�，增强的for循环提供了一个简单、兼容的语法。有两点值得一提：(x��)
Init表达�?/b>
　　在��@环中�Q�初始化表达式只计算一�ơ。这意味着�(zh��n)�通常可以�U�除一个变量声明。在�q�个例子中，我们必须创徏一个整型数�l�来保存computeNumbers()的结果，以防止每一�ơ��@环都重新计算该方法。�?zh��n)�可以看到�Q�下面的代码要比上面的代码整�z�一些，�q�且没有泄露变量numbers�Q?
未增强的For�Q? int sum = 0; Integer[] numbers = computeNumbers(); for (int i=0; i < numbers.length ; i++) sum += numbers[i]; 增强后的For�Q? int sum = 0; for ( int number: computeNumbers() ) sum += number;
局限�?/b>
有时需要在�q�代期间讉K��q�代器或下标�Q�看��h��增强的for循环应该允许该操作，但事实上不是�q�样�Q�请看下面的例子�Q?
for (int i=0; i < numbers.length ; i++) { if (i != 0) System.out.print(","); System.out.print(numbers[i]); }
　　我们希望��数�l�中的值打��Cؓ(f��)一个用逗号分隔的清单。我们需要知道目前是否是�W�一��，以便��定是否应该打印逗号。��用增强的for循环是无法获知这�U�信息的。我们需要自�׃��留一个下标或一个布?y��u)��(d��ng)值来指示是否�l�过了第一��V�?　　�q�是另一个例子：(x��)
for (Iterator it = n.iterator() ; it.hasNext() ; ) if (it.next() < 0) it.remove();
　　在此例中�Q�我们想从整数集合中删除负数��V��ؓ(f��)此，需要对�q�代器调用一个方法，但是当��用增强的for 循环�Ӟ��q�代器对我们来说是看不到的。因此，我们只能使用Java 5之前版本的�P代方法�?　　��Z��说一下，�q�里需要注意的是，�׃��Iterator是泛型，所以其声明是Iterator。许多�h都忘��C��q�一点而��用了Iterator的原始格式�?
注释
　　注释处理是一个很大的话题。因为本文只��x��核心的语�a��Ҏ(gu��)��，所以我们不打算�늛�它所有的可能形式和陷阱。　　我们��讨论内�|�的注释�Q�SuppressWarnings�Q�Deprecated和Override�Q�以�?qi��ng)一般注释处理的局限性�?
Suppress Warnings
　　该注释关闭了�c�L��Ҏ(gu��)��U�别的编译器警告。有时候�?zh��n)�比编译器更清楚地知道�Q�代码必��M��用一个被否决的方法或执行一些无法静态确定是否类型安全的动作�Q�而��用：(x��)
@SuppressWarnings("deprecation") public static void selfDestruct() { Thread.currentThread().stop(); }
　　�q�可能是内置注释最有用的地斏V��遗憄��是，1.5.0_04的javac不支持它。但�?.6支持它，�q�且Sun正在努力��其向后�U�L��?.5中�?
Eclipse 3.1中支持该注释�Q�其他IDE也可能支持它。这允许�(zh��n)�把代码��d��C��警告中解脱出来。如果在�~�译时出现警告，可以��定是�?zh��n)�刚刚把它��d��q�来——以帮助查看那些可能不安全的代码。随着泛型的添加，它��用�v来将更趁手�?
Deprecated
　　遗憾的是�Q�Deprecated没那么有用。它本来旨在替换@deprecated javadoc标签�Q�但是由于它不包含�Q何字�D�，所以也��没有方法来��deprecated�c�L��Ҏ(gu��)��的用户应该��用什么做为替代品。大多数用法都同旉��要javadoc标签和这个注释�?
Override
　　Override表示�Q�它所注释的方法应该重写超�c�M��h��相同�{�֐�的方法：(x��)
@Override public int hashCode() { ... }
　　看上面的例子�Q�如果没有在hashCode中将“C”大写，在编译时不会(x��)出现错误�Q�但是在�q�行时将无法像期望的那样调用该方法。通过��d��Override标签�Q�编译器�?x��)提�C�它是否真正地执行了重写�?
　　在超�c�d��生改变的情况中，�q�也很有帮助。如果向该方法中��d��一个新参数�Q�而且�Ҏ(gu��)��本��n也被重命名了�Q�那么子�c�d��H�然不能�~�译�Q�因为它不再重写��类的�Q何东�ѝ�?
其它注释
　　注释在其他场景中非常有用。当不是直接修改行�ؓ(f��)而是增强行�ؓ(f��)�Ӟ��特别是在��d��h��代码的情况下�Q�注释在诸如EJB�?a target="_blank">Web services�q�样的框架中�q�行得非常好�?
注释不能用做预处理器。Sun的设计特别预防了完全因�ؓ(f��)注释而修改类的字节码。这样可以正��地理解该语�a�的成果，而且IDE之类的工具也可以执行深入的代码分析和重构之类的功能�?
注释不是银弹。第一�ơ遇到的时候，��Z��试图��试各种技巧。请看下面这个从别�h那里获得的徏议：(x��)
public class Foo { @Property private int bar; }
　　其思想是�ؓ(f��)�U�有字段bar自动创徏getter和setter�Ҏ(gu��)��。遗憄��是，�q�个��x��有两个失败之处：(x��)1)它不能运行，2)它��代码难以阅读和处理�?　　它是无法实现的，因�ؓ(f��)前面已经提到了，Sun特别��L��了对出现注释的类�q�行修改�?
　　即��是可能的�Q�它也不是一个好��L��Q�因为它使代码可��L��差。第一�ơ看到这�D�代码的��Z��(x��)不知道该注释创徏了方法。此外，如果��来�(zh��n)�需要在�q�些�Ҏ(gu��)��内部执行一些操作，注释也是没用的�?　　��M��Q�不要试囄��注释��d��那些常规代码可以完成的事情�?
枚�D
　　enum非常像public static final int声明�Q�后者作为枚丑ր�已�l��用了很多�q�。对int所做的最大也是最明显的改�q�是�c�d��安全——�?zh��n)�不能错误地用枚�D的一�U�类型代替另一�U�类型，�q�一点和int不同�Q�所有的int对编译器来说都是一��L(f��ng)��。除��L��数例外的情况，通常都应该用enum实例替换全部的枚��N��格的int�l�构�?
　　枚�D提供了一些附加的�Ҏ(gu��)��。EnumMap和EnumSet�q�两个实用类是专门�ؓ(f��)枚�D优化的标准集合实现。如果知道集合只包含枚�D�c�d��Q�那么应该��用这些专门的集合来代替HashMap或HashSet�?
　　大部分情况下�Q�可以��用enum对代码中的所有public static final int做插入替换。它们是可比的，�q�且可以静态导入，所以对它们的引用看��h��是等同的�Q�即使是对于内部�c�（或内部枚丄��型）。注意，比较枚�D�c�d��的时候，声明它们的指令表明了它们的顺序倹{�?

“隐藏的”静态方�?
　　两个静态方法出现在所有枚丄��型声明中。因为它们是枚�D子类上的静态方法，而不是Enum本��n的方法，所以它们在java.lang.Enum的javadoc中没有出现�?
　　�W�一个是values()�Q�返回一个枚丄��型所有可能值的数组�?
　　�W�二个是valueOf()�Q��ؓ(f��)提供的字�W�串�q�回一个枚丄��型，该枚丄��型必��ȝ��地匚w��源代码声明�?
�Ҏ(gu��)��
　　关于枚�D�c�d��Q�我们最喜欢的一个方面是它可以有�Ҏ(gu��)��。过��L��可能需要编写一些代码，对public static final int�q�行转换�Q�把它从数据库类型�{换�ؓ(f��)JDBC URL。而现在则可以让枚丄��型本�w�带一个整理代码的�Ҏ(gu��)��。下面就是一个例子，包括DatabaseType枚�D�c�d��的抽象方法以�?qi��ng)每个枚丑֮�例中提供的实玎ͼ?x��)
public enum DatabaseType { ORACLE { public String getJdbcUrl() {...} }, MYSQL { public String getJdbcUrl() {...} }; public abstract String getJdbcUrl(); }
　　现在枚�D�c�d��可以直接提供它的实用�Ҏ(gu��)��。例如：(x��)

DatabaseType dbType = ...;
String jdbcURL = dbType.getJdbcUrl();

　　要获取URL�Q�必��预先知道该实用�Ҏ(gu��)��在哪里�?

可变参数(Vararg)
　　正确��C��用可变参数确实可以清理一些垃圾代码。典型的例子是一个带有可变的String参数个数的log�Ҏ(gu��)��Q?
Log.log(String code) Log.log(String code, String arg) Log.log(String code, String arg1, String arg2) Log.log(String code, String[] args)
　　当讨论可变参数时�Q�比较有��的是，如果用新的可变参数替换前四个例子�Q�将是兼容的�Q?
Log.log(String code, String... args)
　　所有的可变参数都是源兼容的——那��是��_(d��)��如果重新�~�译log()�Ҏ(gu��)��的所有调用程序，可以直接替换全部的四个方法。然而，如果需要向后的二进制兼�Ҏ(gu��)��，那么��需要舍��d��三个�Ҏ(gu��)��。只有最后那个带一个字�W�串数组参数的方法等效于可变参数版本�Q�因此可以被可变参数版本替换�?

�c�d��强制转换
　　如果希望调用�E�序了解应该使用哪种�c�d��的参敎ͼ�那么应该避免用可变参数进行类型强制�{换。看下面�q�个例子�Q�第一��希望是String�Q�第二项希望是Exception�Q?
Log.log(Object... objects) { String message = (String)objects[0]; if (objects.length > 1) { Exception e = (Exception)objects[1]; // Do something with the exception } }
　　�Ҏ(gu��)��{�֐�应该如下所�C�，相应的可变参数分别��用String和Exception声明�Q?

Log.log(String message, Exception e, Object... objects) {...}

　　不要使用可变参数破坏�c�d��pȝ��。需要强�c�d��化时才可以��用它。对于这个规则，PrintStream.printf()是一个有��的例外�Q�它提供�c�d��信息作�ؓ(f��)自己的第一个参敎ͼ�以便�E�后可以接受那些�c�d��?

协变�q�回
　　协变�q�回的基本用法是用于在已知一个实现的�q�回�c�d��比API更具体的时候避免进行类型强制�{换。在下面�q�个例子中，有一个返回Animal对象的Zoo接口。我们的实现�q�回一个AnimalImpl对象�Q�但是在JDK 1.5之前�Q�要�q�回一个Animal对象��必��d��明�?
public interface Zoo { public Animal getAnimal(); } public class ZooImpl implements Zoo { public Animal getAnimal(){ return new AnimalImpl(); } }
　　协变�q�回的��用替换了三个反模式：(x��)
直接字段讉K��。�ؓ(f��)了规避API限制�Q�一些实现把子类直接暴露为字�D�：(x��)
ZooImpl._animal
另一�U��Ş式是�Q�在知道实现的实际上是特定的子类的情况下�Q�在调用�E�序中执行向下�{换：(x��)
((AnimalImpl)ZooImpl.getAnimal()).implMethod();
我看到的最后一�U��Ş式是一个具体的�Ҏ(gu��)��Q�该�Ҏ(gu��)��用来避免�׃��个完全不同的�{�֐�所引发的问题：(x��)
ZooImpl._getAnimal();

　　�q�三�U�模式都有它们的问题和局限性。要么是不够整洁�Q�要么就是暴露了不必要的实现�l�节�?

协变
　　协变�q�回模式��比较整�z�、安全�ƈ且易于维护，它也不需要类型强制�{换或特定的方法或字段�Q?
public AnimalImpl getAnimal(){
return new AnimalImpl();
}
　　使用�l�果�Q?
ZooImpl.getAnimal().implMethod();

使用泛型
　　我们��从两个角度来了解泛型：(x��)使用泛型和构造泛型。我们不讨论List、Set和Map的显而易见的用法。知道泛型集合是强大的�ƈ且应该经�怋�用就��_��了�?
　　我们��讨论泛型方法的使用以及(qi��ng)�~�译器推断类型的�Ҏ(gu��)��。通常�q�些都不�?x��)出问题�Q�但是当出问题时�Q�错误信息会(x��)非常令�h费解�Q�所以需要了解如何修复这些问题�?
泛型�Ҏ(gu��)��
　　除了泛型�c�d��Q�Java 5�q�引入了泛型�Ҏ(gu��)��。在�q�个来自java.util.Collections的例子中�Q�构造了一个单元素列表。新的List的元素类型是�Ҏ(gu��)��传入�Ҏ(gu��)��的对象的�c�d��来推断的�Q?
static List Collections.singletonList(T o) �C�Z��用法�Q? public List getListOfOne() { return Collections.singletonList(1); }
　　在示例用法中�Q�我们传入了一个int。所以方法的�q�回�c�d��是List。编译器把T推断为Integer。这和泛型类型是不同的，因�ؓ(f��)�(zh��n)�通常不需要显式地指定�c�d��参数�?
�q�也昄��了自动装��和泛型的相互作用。类型参数必��L��引用�c�d��Q�这��是��Z��么我们得到的是List而不是List�?
不带参数的泛型方�?br />　　emptyList()�Ҏ(gu��)��与泛型一起引入，作�ؓ(f��)java.util.Collections中EMPTY_LIST字段的类型安全置换：(x��)
static List Collections.emptyList() �C�Z��用法�Q? public List getNoIntegers() { return Collections.emptyList(); }
　　与先前的例子不同�Q�这个方法没有参敎ͼ�那么�~�译器如何推断T的类型呢�Q�基本上�Q�它?y��u)��尝试��用一�ơ参数。如果没有�v作用�Q�它再次��试使用�q�回或赋值类型。在本例中，�q�回的是List�Q�所以T被推断�ؓ(f��)Integer�?
　　如果在返回语句或赋��D��句之外的位置调用泛型�Ҏ(gu��)��?x��)怎么样呢�Q�那么编译器��无法执行类型推断的�W�二�ơ传送。在下面�q�个例子中，emptyList()是从条�g�q�算�W�内部调用的�Q?
public List getNoIntegers() { return x ? Collections.emptyList() : null; }
　　因�ؓ(f��)�~�译器看不到�q�回上下文，也不能推断T�Q�所以它攑ּ��q��用Object。�?zh��n)��看��C��个错误消息，比如�Q�“无法将List转换为List。�?
��Z��修复�q�个错误�Q�应昑ּ�地向�Ҏ(gu��)��调用传递类型参数。这��P��~�译器就不会(x��)试图推断�c�d��参数�Q�就可以获得正确的结果：(x��)
return x ? Collections.emptyList() : null;
　　�q�种情况�l�常发生的另一个地�Ҏ(gu��)��在方法调用中。如果一个方法带一个List参数�Q��ƈ且需要�ؓ(f��)那个参数调用�q�个传递的emptyList()�Q�那么也需要��用这个语法�?
集合之外
　　�q�里有三个泛型类型的例子�Q�它们不是集合，而是以一�U�新颖的方式使用泛型。这三个例子都来自标准的Java库：(x��)
Class
Class在类的类型上被参数化了。这��׃��无需�c�d��强制转换而构造一个newInstance成�ؓ(f��)可能�?
Comparable
Comparable被实际的比较�c�d��参数化。这��在compareTo()调用时提供了更强的类型化。例如，String实现Comparable。对除String之外的�Q何东西调用compareTo()�Q�都�?x��)在�~�译时失败�?
Enum>
Enum被枚丄��型参数化。一个名为Color的枚丄��型将扩展Enum。getDeclaringClass()�Ҏ(gu��)��q�回枚�D�c�d��的类对象�Q�在�q�个例子中就是一个Color对象。它与getClass()不同�Q�后者可能返回一个无名类�?
通配�W?br />　　泛型最复杂的部分是寚w��配�W�的理解。我们将讨论三种�c�d��的通配�W�以�?qi��ng)它们的用途�?
　　首先让我们了解一下数�l�是如何工作的。可以从一个Integer[]��Z��个Number[]赋倹{��如果尝试把一个Float写到Number[]中，那么可以�~�译�Q�但在运行时�?x��)失败，出现一个ArrayStoreException�Q?
Integer[] ia = new Integer[5]; Number[] na = ia; na[0] = 0.5; // compiles, but fails at runtime 如果试图把该例直接�{换成泛型�Q�那么会(x��)在编译时��p�|�Q�因��值是不被允许的：(x��) List iList = new ArrayList(); List nList = iList; // not allowed nList.add(0.5);
　　如果使用泛型�Q�只要代码在�~�译时没有出现警告，��׃��?x��)遇到运行时ClassCastException�?
上限通配�W?/b>
　　我们惌��的是一个确切元素类型未知的列表�Q�这一点与数组是不同的�?
List是一个列表，其元素类型是具体�c�d��Number�?
List是一个确切元素类型未知的列表。它是Number或其子类型�?
上限
　　如果我们更新初始的例子，�q�赋值给List�Q�那么现在赋值就�?x��)成功了�Q?
List iList = new ArrayList(); List nList = iList; Number n = nList.get(0); nList.add(0.5); // Not allowed
　　我们可以从列表中得到Number�Q�因为无论列表的��切元素�c�d��是什么（F(tu��n)loat、Integer或Number�Q�，我们都可以把它赋值给Number�?
　　我们仍然不能把��Q点类型插入列表中。这�?x��)在�~�译时失败，因�ؓ(f��)我们不能证明�q�是安全的。如果我们想要向列表中添加��Q点类型，它将破坏iList的初始类型安全——它只存储Integer�?
　　通配�W�给了我们比数组更多的表达能力�?
��Z��么��用通配�W?br />　　在下面这个例子中�Q�通配�W�用于向API的用户隐藏类型信息。在内部�Q�Set被存储�ؓ(f��)CustomerImpl。而API的用户只知道他们正在获取一个Set�Q�从中可以读取Customer�?
此处通配�W�是必需的，因�ؓ(f��)无法从Set向Set赋��|��(x��)
public class CustomerFactory { private Set _customers; public Set getCustomers() { return _customers; } }
通配�W�和协变�q�回
　　通配�W�的另一�U�常见用法是和协变返回一起��用。与赋值相同的规则可以应用到协变返回上。如果希望在重写的方法中�q�回一个更具体的泛型类型，声明的方法必��M��用通配�W�：(x��)
public interface NumberGenerator { public List generate(); } public class FibonacciGenerator extends NumberGenerator { public List generate() { ... } }
　　如果要��用数�l�，接口可以�q�回Number[]�Q�而实现可以返回Integer[]�?
下限
　　我们所谈的主要是关于上限通配�W�的。还有一个下限通配�W�。List是一个确切“元素类型”未知的列表�Q�但是可能是Mnumber�Q�或者Number的超�c�d��。所以它可能是一个List或一个List�?
　　下限通配�W�远没有上限通配�W�那样常见，但是当需要它们的时候，它们��是必需的�?
下限与上�?br />
List readList = new ArrayList(); Number n = readList.get(0); List writeList = new ArrayList(); writeList.add(new Integer(5));
　　�W�一个是可以从中��L��的列表�?
　　�W�二个是可以向其写数的列表�?
无界通配�W?/b>
　　最后，List列表的内容可以是��M��c�d��Q�而且它与List几乎相同。可以随时读取Object�Q�但是不能向列表中写入内宏V�?
公共API中的通配�W?
　　��M��Q�正如前面所��_(d��)��通配�W�在向调用程序隐藏实现细节方面是非常重要的，但即使下限通配�W�看��h��是提供只读访问，�׃��remove(int position)之类的非泛型�Ҏ(gu��)��Q�它们也�q��如此。如果�?zh��n)�惌��一个真正不变的集合�Q�可以��用java.util.Collection上的�Ҏ(gu��)��Q�比如unmodifiableList()�?
　　�~�写API的时候要记得通配�W�。通常�Q�在传递泛型类型时�Q�应该尝试��用通配�W�。它使更多的调用�E�序可以讉K��API�?
　　通过接收List而不是List�Q�下面的�Ҏ(gu��)��可以��p��多不同类型的列表调用�Q?
void removeNegatives(List list);
构造泛型类�?/b>
　　现在我们��讨论构造自��q��泛型�c�d��。我们将展示一些例子，其中通过使用泛型可以提高�c�d��安全性，我们�q�将讨论一些实现泛型类型时的常见问题�?/p>
集合风格(Collection-like)的函�?/b>
　　�W�一个泛型类的例子是一个集合风格的例子。Pair有两个类型参敎ͼ�而且字段是类型的实例�Q?
public final class Pair { public final A first; public final B second; public Pair(A first, B second) { this.first = first; this.second = second; } }
　　�q��从方法返回两个项而无需为每个两�U�类型的�l�合�~�写专用的类成�ؓ(f��)可能。另一�U�方法是�q�回Object[]�Q�而这��h��c�d��不安全或者不整洁的�?
在下面的用法中，我们从方法返回一个File和一个Boolean。方法的客户端可以直接��用字�D�而无需�c�d��强制转换�Q?
public Pair getFileAndWriteStatus(String path){ // create file and status return new Pair(file, status); } Pair result = getFileAndWriteStatus("..."); File f = result.first; boolean writeable = result.second;
集合之外
　　在下面这个例子中�Q�泛型被用于附加的编译时安全性。通过把DBFactory�c�d��数化为所创徏的Peer�c�d��Q��?zh��n)�实际上是在强制Factory子类�q�回一个Peer的特定子�c�d��Q?
public abstract class DBFactory { protected abstract T createEmptyPeer(); public List get(String constraint) { List peers = new ArrayList(); // database magic return peers; } } 通过实现DBFactory�Q�CustomerFactory必须从createEmptyPeer()�q�回一个Customer�Q? public class CustomerFactory extends DBFactory{ public Customer createEmptyPeer() { return new Customer(); } }
泛型�Ҏ(gu��)��
　　不管惌��对参��C��间还是参��C��q�回�c�d��之间的泛型类型施加约束，都可以��用泛型方法：(x��)
　　例如�Q�如果编写的反�{函数是在位置上反转，那么可能不需要泛型方法。然而，如果希望反�{�q�回一个新的List�Q�那么可能会(x��)希望新List的元素类型与传入的List的类型相同。在�q�种情况下，��需要一个泛型方法：(x��)

List reverse(List list)
具体�?br />　　当实��C��个泛型类�Ӟ��(zh��n)�可能想要构造一个数�l�T[]。因为泛型是通过擦除(erasure)实现的，所以这是不允许的�?
　　�(zh��n)�可以尝试把Object[]强制转换为T[]。但�q�是不安全的�?
具体化解��x��?br />　　按照泛型教程的惯例，解决�Ҏ(gu��)��使用的是“类型��o(h��)牌”，通过向构造函数添加一个Class参数�Q�可以强制客��L(f��ng)��为类的类型参数提供正��的�c�d��象：(x��)
public class ArrayExample { private Class clazz; public ArrayExample(Class clazz) { this.clazz = clazz; } public T[] getArray(int size) { return (T[])Array.newInstance(clazz, size); } }
　　��Z��构造ArrayExample�Q�客��L(f��ng)��必须把String.class传递给构造函敎ͼ�因�ؓ(f��)String.class的类型是Class�?
拥有�c�d��象��构造一个具有正��元素类型的数组成�ؓ(f��)可能�?

引用　http://dev2dev.bea.com.cn/techdoc/20060105718.html

zeroone0 2006-04-05 07:51 发表评论

jsp��面中的下蝲功能实现

zeroone0 — Mon, 03 Apr 2006 02:02:00 GMT

<%
String filename="test.jpg";
String dirName=application.getRealPath("/WEB-INF/upload");
java.io.File ff=null;
String dd=dirName+System.getProperties().getProperty("file.separator")+filename;
try{
ff=new java.io.File(dd);
}
catch(Exception e){
e.printStackTrace();
}
if (ff!=null&&ff.exists()&&ff.isFile())
{
long filelength = ff.length();
InputStream inStream=new FileInputStream(dd);
//讄��输出的格�?
response.reset();
response.setContentType("application/x-msdownload");
response.setContentLength((int)filelength);
response.addHeader("Content-Disposition","attachment; filename=\"" + toUtf8String(filename) + "\"");
//循环取出��中的数�?
byte[] b = new byte[100];
int len;
while((len=inStream.read(b)) >0)
response.getOutputStream().write(b,0,len);
inStream.close();
}
%>

zeroone0 2006-04-03 10:02 发表评论

Web文�g的ContentType�c�d��

zeroone0 — Mon, 03 Apr 2006 01:59:00 GMT

Web文�g的ContentType�c�d��

".*"="application/octet-stream"
".001"="application/x-001"
".301"="application/x-301"
".323"="text/h323"
".906"="application/x-906"
".907"="drawing/907"
".a11"="application/x-a11"
".acp"="audio/x-mei-aac"
".ai"="application/postscript"
".aif"="audio/aiff"
".aifc"="audio/aiff"
".aiff"="audio/aiff"
".anv"="application/x-anv"
".asa"="text/asa"
".asf"="video/x-ms-asf"
".asp"="text/asp"
".asx"="video/x-ms-asf"
".au"="audio/basic"
".avi"="video/avi"
".awf"="application/vnd.adobe.workflow"
".biz"="text/xml"
".bmp"="application/x-bmp"
".bot"="application/x-bot"
".c4t"="application/x-c4t"
".c90"="application/x-c90"
".cal"="application/x-cals"
".cat"="application/vnd.ms-pki.seccat"
".cdf"="application/x-netcdf"
".cdr"="application/x-cdr"
".cel"="application/x-cel"
".cer"="application/x-x509-ca-cert"
".cg4"="application/x-g4"
".cgm"="application/x-cgm"
".cit"="application/x-cit"
".class"="java/*"
".cml"="text/xml"
".cmp"="application/x-cmp"
".cmx"="application/x-cmx"
".cot"="application/x-cot"
".crl"="application/pkix-crl"
".crt"="application/x-x509-ca-cert"
".csi"="application/x-csi"
".css"="text/css"
".cut"="application/x-cut"
".dbf"="application/x-dbf"
".dbm"="application/x-dbm"
".dbx"="application/x-dbx"
".dcd"="text/xml"
".dcx"="application/x-dcx"
".der"="application/x-x509-ca-cert"
".dgn"="application/x-dgn"
".dib"="application/x-dib"
".dll"="application/x-msdownload"
".doc"="application/msword"
".dot"="application/msword"
".drw"="application/x-drw"
".dtd"="text/xml"
".dwf"="Model/vnd.dwf"
".dwf"="application/x-dwf"
".dwg"="application/x-dwg"
".dxb"="application/x-dxb"
".dxf"="application/x-dxf"
".edn"="application/vnd.adobe.edn"
".emf"="application/x-emf"
".eml"="message/rfc822"
".ent"="text/xml"
".epi"="application/x-epi"
".eps"="application/x-ps"
".eps"="application/postscript"
".etd"="application/x-ebx"
".exe"="application/x-msdownload"
".fax"="image/fax"
".fdf"="application/vnd.fdf"
".fif"="application/fractals"
".fo"="text/xml"
".frm"="application/x-frm"
".g4"="application/x-g4"
".gbr"="application/x-gbr"
".gcd"="application/x-gcd"
".gif"="image/gif"
".gl2"="application/x-gl2"
".gp4"="application/x-gp4"
".hgl"="application/x-hgl"
".hmr"="application/x-hmr"
".hpg"="application/x-hpgl"
".hpl"="application/x-hpl"
".hqx"="application/mac-binhex40"
".hrf"="application/x-hrf"
".hta"="application/hta"
".htc"="text/x-component"
".htm"="text/html"
".html"="text/html"
".htt"="text/webviewhtml"
".htx"="text/html"
".icb"="application/x-icb"
".ico"="image/x-icon"
".ico"="application/x-ico"
".iff"="application/x-iff"
".ig4"="application/x-g4"
".igs"="application/x-igs"
".iii"="application/x-iphone"
".img"="application/x-img"
".ins"="application/x-internet-signup"
".isp"="application/x-internet-signup"
".IVF"="video/x-ivf"
".java"="java/*"
".jfif"="image/jpeg"
".jpe"="image/jpeg"
".jpe"="application/x-jpe"
".jpeg"="image/jpeg"
".jpg"="image/jpeg"
".jpg"="application/x-jpg"
".js"="application/x-javascript"
".jsp"="text/html"
".la1"="audio/x-liquid-file"
".lar"="application/x-laplayer-reg"
".latex"="application/x-latex"
".lavs"="audio/x-liquid-secure"
".lbm"="application/x-lbm"
".lmsff"="audio/x-la-lms"
".ls"="application/x-javascript"
".ltr"="application/x-ltr"
".m1v"="video/x-mpeg"
".m2v"="video/x-mpeg"
".m3u"="audio/mpegurl"
".m4e"="video/mpeg4"
".mac"="application/x-mac"
".man"="application/x-troff-man"
".math"="text/xml"
".mdb"="application/msaccess"
".mdb"="application/x-mdb"
".mfp"="application/x-shockwave-flash"
".mht"="message/rfc822"
".mhtml"="message/rfc822"
".mi"="application/x-mi"
".mid"="audio/mid"
".midi"="audio/mid"
".mil"="application/x-mil"
".mml"="text/xml"
".mnd"="audio/x-musicnet-download"
".mns"="audio/x-musicnet-stream"
".mocha"="application/x-javascript"
".movie"="video/x-sgi-movie"
".mp1"="audio/mp1"
".mp2"="audio/mp2"
".mp2v"="video/mpeg"
".mp3"="audio/mp3"
".mp4"="video/mpeg4"
".mpa"="video/x-mpg"
".mpd"="application/vnd.ms-project"
".mpe"="video/x-mpeg"
".mpeg"="video/mpg"
".mpg"="video/mpg"
".mpga"="audio/rn-mpeg"
".mpp"="application/vnd.ms-project"
".mps"="video/x-mpeg"
".mpt"="application/vnd.ms-project"
".mpv"="video/mpg"
".mpv2"="video/mpeg"
".mpw"="application/vnd.ms-project"
".mpx"="application/vnd.ms-project"
".mtx"="text/xml"
".mxp"="application/x-mmxp"
".net"="image/pnetvue"
".nrf"="application/x-nrf"
".nws"="message/rfc822"
".odc"="text/x-ms-odc"
".out"="application/x-out"
".p10"="application/pkcs10"
".p12"="application/x-pkcs12"
".p7b"="application/x-pkcs7-certificates"
".p7c"="application/pkcs7-mime"
".p7m"="application/pkcs7-mime"
".p7r"="application/x-pkcs7-certreqresp"
".p7s"="application/pkcs7-signature"
".pc5"="application/x-pc5"
".pci"="application/x-pci"
".pcl"="application/x-pcl"
".pcx"="application/x-pcx"
".pdf"="application/pdf"
".pdf"="application/pdf"
".pdx"="application/vnd.adobe.pdx"
".pfx"="application/x-pkcs12"
".pgl"="application/x-pgl"
".pic"="application/x-pic"
".pko"="application/vnd.ms-pki.pko"
".pl"="application/x-perl"
".plg"="text/html"
".pls"="audio/scpls"
".plt"="application/x-plt"
".png"="image/png"
".png"="application/x-png"
".pot"="application/vnd.ms-powerpoint"
".ppa"="application/vnd.ms-powerpoint"
".ppm"="application/x-ppm"
".pps"="application/vnd.ms-powerpoint"
".ppt"="application/vnd.ms-powerpoint"
".ppt"="application/x-ppt"
".pr"="application/x-pr"
".prf"="application/pics-rules"
".prn"="application/x-prn"
".prt"="application/x-prt"
".ps"="application/x-ps"
".ps"="application/postscript"
".ptn"="application/x-ptn"
".pwz"="application/vnd.ms-powerpoint"
".r3t"="text/vnd.rn-realtext3d"
".ra"="audio/vnd.rn-realaudio"
".ram"="audio/x-pn-realaudio"
".ras"="application/x-ras"
".rat"="application/rat-file"
".rdf"="text/xml"
".rec"="application/vnd.rn-recording"
".red"="application/x-red"
".rgb"="application/x-rgb"
".rjs"="application/vnd.rn-realsystem-rjs"
".rjt"="application/vnd.rn-realsystem-rjt"
".rlc"="application/x-rlc"
".rle"="application/x-rle"
".rm"="application/vnd.rn-realmedia"
".rmf"="application/vnd.adobe.rmf"
".rmi"="audio/mid"
".rmj"="application/vnd.rn-realsystem-rmj"
".rmm"="audio/x-pn-realaudio"
".rmp"="application/vnd.rn-rn_music_package"
".rms"="application/vnd.rn-realmedia-secure"
".rmvb"="application/vnd.rn-realmedia-vbr"
".rmx"="application/vnd.rn-realsystem-rmx"
".rnx"="application/vnd.rn-realplayer"
".rp"="image/vnd.rn-realpix"
".rpm"="audio/x-pn-realaudio-plugin"
".rsml"="application/vnd.rn-rsml"
".rt"="text/vnd.rn-realtext"
".rtf"="application/msword"
".rtf"="application/x-rtf"
".rv"="video/vnd.rn-realvideo"
".sam"="application/x-sam"
".sat"="application/x-sat"
".sdp"="application/sdp"
".sdw"="application/x-sdw"
".sit"="application/x-stuffit"
".slb"="application/x-slb"
".sld"="application/x-sld"
".slk"="drawing/x-slk"
".smi"="application/smil"
".smil"="application/smil"
".smk"="application/x-smk"
".snd"="audio/basic"
".sol"="text/plain"
".sor"="text/plain"
".spc"="application/x-pkcs7-certificates"
".spl"="application/futuresplash"
".spp"="text/xml"
".ssm"="application/streamingmedia"
".sst"="application/vnd.ms-pki.certstore"
".stl"="application/vnd.ms-pki.stl"
".stm"="text/html"
".sty"="application/x-sty"
".svg"="text/xml"
".swf"="application/x-shockwave-flash"
".tdf"="application/x-tdf"
".tg4"="application/x-tg4"
".tga"="application/x-tga"
".tif"="image/tiff"
".tif"="application/x-tif"
".tiff"="image/tiff"
".tld"="text/xml"
".top"="drawing/x-top"
".torrent"="application/x-bittorrent"
".tsd"="text/xml"
".txt"="text/plain"
".uin"="application/x-icq"
".uls"="text/iuls"
".vcf"="text/x-vcard"
".vda"="application/x-vda"
".vdx"="application/vnd.visio"
".vml"="text/xml"
".vpg"="application/x-vpeg005"
".vsd"="application/vnd.visio"
".vsd"="application/x-vsd"
".vss"="application/vnd.visio"
".vst"="application/vnd.visio"
".vst"="application/x-vst"
".vsw"="application/vnd.visio"
".vsx"="application/vnd.visio"
".vtx"="application/vnd.visio"
".vxml"="text/xml"
".wav"="audio/wav"
".wax"="audio/x-ms-wax"
".wb1"="application/x-wb1"
".wb2"="application/x-wb2"
".wb3"="application/x-wb3"
".wbmp"="image/vnd.wap.wbmp"
".wiz"="application/msword"
".wk3"="application/x-wk3"
".wk4"="application/x-wk4"
".wkq"="application/x-wkq"
".wks"="application/x-wks"
".wm"="video/x-ms-wm"
".wma"="audio/x-ms-wma"
".wmd"="application/x-ms-wmd"
".wmf"="application/x-wmf"
".wml"="text/vnd.wap.wml"
".wmv"="video/x-ms-wmv"
".wmx"="video/x-ms-wmx"
".wmz"="application/x-ms-wmz"
".wp6"="application/x-wp6"
".wpd"="application/x-wpd"
".wpg"="application/x-wpg"
".wpl"="application/vnd.ms-wpl"
".wq1"="application/x-wq1"
".wr1"="application/x-wr1"
".wri"="application/x-wri"
".wrk"="application/x-wrk"
".ws"="application/x-ws"
".ws2"="application/x-ws"
".wsc"="text/scriptlet"
".wsdl"="text/xml"
".wvx"="video/x-ms-wvx"
".xdp"="application/vnd.adobe.xdp"
".xdr"="text/xml"
".xfd"="application/vnd.adobe.xfd"
".xfdf"="application/vnd.adobe.xfdf"
".xhtml"="text/html"
".xls"="application/vnd.ms-excel"
".xls"="application/x-xls"
".xlw"="application/x-xlw"
".xml"="text/xml"
".xpl"="audio/scpls"
".xq"="text/xml"
".xql"="text/xml"
".xquery"="text/xml"
".xsd"="text/xml"
".xsl"="text/xml"
".xslt"="text/xml"
".xwd"="application/x-xwd"
".x_b"="application/x-x_b"
".x_t"="application/x-x_t"

zeroone0 2006-04-03 09:59 发表评论

zeroone0 — Mon, 03 Apr 2006 01:55:00 GMT

�W?�?基础知识

1.1. 单钥密码体制
单钥密码体制是一�U�传�l�的加密��法�Q�是指信息的发送方和接收方共同使用同一把密钥进行加解密�?/p>
通常,使用的加密算�?比较��侉K��?密钥��短，加解密速度快，破译极其困难。但是加密的安全性依靠密钥保��的安全�?在公开的计��机�|�络上安全地传送和保管密钥是一个严�ȝ��问题�Q��ƈ且如果在多用��L(f��ng)��情况下密钥的保管安全性也是一个问题�?/p>
单钥密码体制的代表是��国的DES

1.2. 消息摘要
一个消息摘要就是一个数据块的数字指�U�V��即对一个�Q意长度的一个数据块�q�行计算�Q��生一个唯一指印�Q�对于SHA1是��生一�?0字节的二�q�制数组�Q��?/p>
消息摘要有两个基本属性：(x��)

两个不同的报文难以生成相同的摘要
难以�Ҏ(gu��)��定的摘要生成一个报文，而由该报文反推算��指定的摘�?br />代表�Q�美国国家标准技术研�I�所的SHA1和麻省理工学院Ronald Rivest提出的MD5

1.3. Diffie-Hellman密钥一致协�?
密钥一致协议是由公开密钥密码体制的奠��Z�hDiffie和Hellman所提出的一�U�思想�?/p>
先决条�g,允许两名用户在公开媒体上交换信息以生成"一�?�?可以�׃�n的密�?/p>
代表�Q�指数密钥一致协�?Exponential Key Agreement Protocol)

1.4. 非对�U�算法与公钥体系
1976�q�_(d��)��Dittie和Hellman��军_��钥管理问题，在他们的奠基性的工作"密码学的新方�?一文中�Q�提��Z��U�密钥交换协议，允许在不安全的媒体上通过通讯双方交换信息�Q�安全地传送秘密密钥。在此新思想的基��上，很快出现了非对称密钥密码体制�Q�即公钥密码体制。在公钥体制中，加密密钥不同于解密密钥，加密密钥公之于众�Q�谁都可以��用；解密密钥只有解密��q��道。它们分别称为公开密钥�Q�Public key�Q�和�U�密密钥�Q�Private key�Q��?

�q�今为止的所有公钥密码体�p�M��Q�RSA�pȝ��是最著名、最多��用的一�U�。RSA公开密钥密码�pȝ��是由R.Rivest、A.Shamir和L.Adleman俊教授于1977�q�提出的。RSA的取名就是来自于�q�三位发明者的姓的�W�一个字�?/p>
1.5. 数字�{�֐�
所谓数字签名就是信息发送者用其私钥对从所传报文中提取出的特征数据�Q�或�U�数字指�U�）�q�行RSA��法操作�Q�以保证发信人无法抵赖曾发过该信息（即不可抵赖性）�Q�同时也��保信息报文在经�{�֐�后末被篡改（卛_��整性）。当信息接收者收到报文后�Q�就可以用发送者的公钥�Ҏ(gu��)��字签名进行验证。　

在数字签名中有重要作用的数字指纹是通过一�cȝ��D�的散列函数�Q�HASH函数�Q�生成的�Q�对�q�些HASH函数的特�D�要求是�Q?

接受的输入报文数据没有长度限�Ӟ��
对�Q何输入报文数据生成固定长度的摘要�Q�数字指�U�）输出
从报文能方便地算出摘要；
难以�Ҏ(gu��)��定的摘要生成一个报文，而由该报文反推算��指定的摘要；
两个不同的报文难以生成相同的摘要

代表�Q�DSA

�W?�?在JAVA中的实现

2.1. 相关
Diffie-Hellman密钥一致协议和DES�E�序需要JCE工具库的支持,可以�?http://java.sun.com/security/index.html 下蝲JCE,�q�进行安装。简易安装把 jce1.2.1\lib 下的所有内容复制到 %java_home%\lib\ext�?如果没有ext目录自行建立,再把jce1_2_1.jar和sunjce_provider.jar��d��到CLASSPATH�?更详�l�说明请看相应用��h��?/p>
2.2. 消息摘要MD5和SHA的��?
使用�Ҏ(gu��)��:

首先用生成一个MessageDigest�c?��定计算�Ҏ(gu��)��

java.security.MessageDigest alga=java.security.MessageDigest.getInstance("SHA-1");

��d��要进行计��摘要的信息

alga.update(myinfo.getBytes());

计算出摘�?/p>
byte[] digesta=alga.digest();

发送给其他��Z��的信息和摘要

其他人用相同的方法初始化,��d��信息,最后进行比较摘要是否相�?/p>
algb.isEqual(digesta,algb.digest())

相关AIP

java.security.MessageDigest �c?/p>
static getInstance(String algorithm)

�q�回一个MessageDigest对象,它实现指定的��法

参数:��法�?�?SHA-1 或MD5

void update (byte input)

void update (byte[] input)

void update(byte[] input, int offset, int len)

��d��要进行计��摘要的信息

byte[] digest()

完成计算,�q�回计算得到的摘�?对于MD5�?6�?SHA�?0�?

void reset()

复位

static boolean isEqual(byte[] digesta, byte[] digestb)

比效两个摘要是否相同

代码�Q?
import java.security.*;
public class myDigest {
public static void main(String[] args) {

myDigest my=new myDigest();
my.testDigest();

}
public void testDigest()
{
try {
String myinfo="我的��试信息";

//java.security.MessageDigest alg=java.security.MessageDigest.getInstance("MD5");
java.security.MessageDigest alga=java.security.MessageDigest.getInstance("SHA-1");
alga.update(myinfo.getBytes());
byte[] digesta=alga.digest();
System.out.println("本信息摘要是:"+byte2hex(digesta));
//通过某中方式传给其他��Z��的信�?myinfo)和摘�?digesta) �Ҏ(gu��)��可以判断是否更改或传输正�?br />java.security.MessageDigest algb=java.security.MessageDigest.getInstance("SHA-1");
algb.update(myinfo.getBytes());
if (algb.isEqual(digesta,algb.digest())) {
System.out.println("信息��查正�?);
}
else
{
System.out.println("摘要不相�?);
}

}
catch (java.security.NoSuchAlgorithmException ex) {
System.out.println("非法摘要��法");
}

}
public String byte2hex(byte[] b) //二行制�{字符�?br />{
String hs="";
String stmp="";
for (int n=0;n {
stmp=(java.lang.Integer.toHexString(b[n] & 0XFF));
if (stmp.length()==1) hs=hs+"0"+stmp;
else hs=hs+stmp;
if (n }
return hs.toUpperCase();
}

}

2.3. 数字�{�֐�DSA

对于一个用��h��讲首先要生成他的密钥�?�q�且分别保存
生成一个KeyPairGenerator实例
java.security.KeyPairGenerator keygen=java.security.KeyPairGenerator.getInstance("DSA");
如果讑֮�随机产生器就用如�总�码初始化
SecureRandom secrand=new SecureRandom();

secrand.setSeed("tttt".getBytes()); //初始化随��Z�生器
keygen.initialize(512,secrand); //初始化密钥生成器
否则
keygen.initialize(512);
生成密钥公钥pubkey和私钥prikey
KeyPair keys=keygen.generateKeyPair(); //生成密钥�l?br />PublicKey pubkey=keys.getPublic();
PrivateKey prikey=keys.getPrivate();
分别保存在myprikey.dat和mypubkey.dat�?以便下次不在生成
(生成密钥对的旉��比较�?br />java.io.ObjectOutputStream out=new java.io.ObjectOutputStream(new java.io.FileOutputStream("myprikey.dat"));
out.writeObject(prikey);
out.close();
out=new java.io.ObjectOutputStream(new java.io.FileOutputStream("mypubkey.dat"));
out.writeObject(pubkey);
out.close();

用他�U��h密钥(prikey)对他所��认的信�?info)�q�行数字�{�֐�产生一个签名数�l?
从文件中��d��U��h密钥(prikey)
java.io.ObjectInputStream in=new java.io.ObjectInputStream(new java.io.FileInputStream("myprikey.dat"));
PrivateKey myprikey=(PrivateKey)in.readObject();
in.close();
初始一个Signature对象,�q�用�U�钥对信息签�?br />java.security.Signature signet=java.security.Signature.getInstance("DSA");
signet.initSign(myprikey);
signet.update(myinfo.getBytes());
byte[] signed=signet.sign();
把信息和�{�֐�保存在一个文件中(myinfo.dat)
java.io.ObjectOutputStream out=new java.io.ObjectOutputStream(new java.io.FileOutputStream("myinfo.dat"));
out.writeObject(myinfo);
out.writeObject(signed);
out.close();
把他的公钥的信息�?qi��ng)签名发�l�其它用�?/p>

其他用户用他的公共密�?pubkey)和签�?signed)和信�?info)�q�行验证是否�׃��{�֐�的信�?
��d��公钥
java.io.ObjectInputStream in=new java.io.ObjectInputStream(new java.io.FileInputStream("mypubkey.dat"));
PublicKey pubkey=(PublicKey)in.readObject();
in.close();

��d��{�֐�和信�?br />in=new java.io.ObjectInputStream(new java.io.FileInputStream("myinfo.dat"));
String info=(String)in.readObject();
byte[] signed=(byte[])in.readObject();
in.close();

初始一个Signature对象,�q�用公钥和签名进行验�?br />java.security.Signature signetcheck=java.security.Signature.getInstance("DSA");
signetcheck.initVerify(pubkey);
signetcheck.update(info.getBytes());
if (signetcheck.verify(signed)) { System.out.println("�{�֐�正常");}

对于密钥的保存本文是用对象流的方式保存和传送的,也可可以用编码的方式保存.注意�?br />import java.security.spec.*
import java.security.*

具休说明如下

public key是用X.509�~�码�?例码如下:
byte[] bobEncodedPubKey=mypublic.getEncoded(); //生成�~�码
//传送二�q�制�~�码
//以下代码转换�~�码为相应key对象
X509EncodedKeySpec bobPubKeySpec = new X509EncodedKeySpec(bobEncodedPubKey);
KeyFactory keyFactory = KeyFactory.getInstance("DSA");
PublicKey bobPubKey = keyFactory.generatePublic(bobPubKeySpec);

对于Private key是用PKCS#8�~�码,例码如下:
byte[] bPKCS=myprikey.getEncoded();
//传送二�q�制�~�码
//以下代码转换�~�码为相应key对象
PKCS8EncodedKeySpec priPKCS8=new PKCS8EncodedKeySpec(bPKCS);
KeyFactory keyf=KeyFactory.getInstance("DSA");
PrivateKey otherprikey=keyf.generatePrivate(priPKCS8);

常用API
java.security.KeyPairGenerator 密钥生成器类
public static KeyPairGenerator getInstance(String algorithm) throws NoSuchAlgorithmException
以指定的��法�q�回一个KeyPairGenerator 对象
参数: algorithm ��法�?�?"DSA","RSA"

public void initialize(int keysize)

以指定的长度初始化KeyPairGenerator对象,如果没有初始化系�l�以1024长度默认讄��

参数:keysize ��法位长.其范围必��d�� 512 �?1024 之间�Q�且必须�?64 的倍数

public void initialize(int keysize, SecureRandom random)
以指定的长度初始化和随机发生器初始化KeyPairGenerator对象
参数:keysize ��法位长.其范围必��d�� 512 �?1024 之间�Q�且必须�?64 的倍数
random 一个随��Z��的来�?对于initialize(int keysize)使用了默认随机器

public abstract KeyPair generateKeyPair()
产生新密钥对

java.security.KeyPair 密钥对类
public PrivateKey getPrivate()
�q�回�U�钥

public PublicKey getPublic()
�q�回公钥

java.security.Signature �{�֐��c?br />public static Signature getInstance(String algorithm) throws NoSuchAlgorithmException
�q�回一个指定算法的Signature对象
参数 algorithm �?"DSA"

public final void initSign(PrivateKey privateKey)
throws InvalidKeyException
用指定的�U�钥初始�?br />参数rivateKey 所�q�行�{�֐�时用的私�?/p>
public final void update(byte data)
throws SignatureException
public final void update(byte[] data)
throws SignatureException
public final void update(byte[] data, int off, int len)
throws SignatureException

��d��要签名的信息

public final byte[] sign()
throws SignatureException
�q�回�{�֐�的数�l?前提是initSign和update

public final void initVerify(PublicKey publicKey)
throws InvalidKeyException
用指定的公钥初始�?br />参数ublicKey 验证时用的公�?/p>
public final boolean verify(byte[] signature)
throws SignatureException
验证�{�֐�是否有效,前提是已�l�initVerify初始�?br />参数: signature �{�֐�数组
*/
import java.security.*;
import java.security.spec.*;
public class testdsa {
public static void main(String[] args) throws java.security.NoSuchAlgorithmException,java.lang.Exception {
testdsa my=new testdsa();
my.run();
}
public void run()
{

//数字�{�֐�生成密钥
//�W�一步生成密钥对,如果已经生成�q?本过�E�就可以跌��,对用��h��讲myprikey.dat要保存在本地
//而mypubkey.dat�l�发布给其它用户
if ((new java.io.File("myprikey.dat")).exists()==false) {
if (generatekey()==false) {
System.out.println("生成密钥对��|");
return;
};
}
//�W�二�?此用�?br />//从文件中��d��U�钥,对一个字�W�串�q�行�{�֐�后保存在一个文�?myinfo.dat)�?br />//�q�且再把myinfo.dat发送出�?br />//��Z��方便数字�{�֐�也放�q�了myifno.dat文�g�?当然也可分别发�?br />try {
java.io.ObjectInputStream in=new java.io.ObjectInputStream(new java.io.FileInputStream("myprikey.dat"));
PrivateKey myprikey=(PrivateKey)in.readObject();
in.close();

// java.security.spec.X509EncodedKeySpec pubX509=new java.security.spec.X509EncodedKeySpec(bX509);

//java.security.spec.X509EncodedKeySpec pubkeyEncode=java.security.spec.X509EncodedKeySpec
String myinfo="�q�是我的信息"; //要签名的信息
//用私钥对信息生成数字�{�֐�
java.security.Signature signet=java.security.Signature.getInstance("DSA");
signet.initSign(myprikey);
signet.update(myinfo.getBytes());
byte[] signed=signet.sign(); //对信息的数字�{�֐�
System.out.println("signed(�{�֐�内容)="+byte2hex(signed));
//把信息和数字�{�֐�保存在一个文件中
java.io.ObjectOutputStream out=new java.io.ObjectOutputStream(new java.io.FileOutputStream("myinfo.dat"));
out.writeObject(myinfo);
out.writeObject(signed);
out.close();
System.out.println("�{�֐��q�生成文件成�?);
}
catch (java.lang.Exception e) {
e.printStackTrace();
System.out.println("�{�֐��q�生成文件失�?);
};

//�W�三�?br />//其他人通过公共方式得到此户的公钥和文�g
//其他人用此户的公�?�Ҏ(gu��)��件进行检�?如果成功说明是此用户发布的信�?
//
try {

java.io.ObjectInputStream in=new java.io.ObjectInputStream(new java.io.FileInputStream("mypubkey.dat"));
PublicKey pubkey=(PublicKey)in.readObject();
in.close();
System.out.println(pubkey.getFormat());

in=new java.io.ObjectInputStream(new java.io.FileInputStream("myinfo.dat"));
String info=(String)in.readObject();
byte[] signed=(byte[])in.readObject();
in.close();

java.security.Signature signetcheck=java.security.Signature.getInstance("DSA");
signetcheck.initVerify(pubkey);
signetcheck.update(info.getBytes());
if (signetcheck.verify(signed)) {
System.out.println("info="+info);
System.out.println("�{�֐�正常");
}
else System.out.println("非签名正�?);
}
catch (java.lang.Exception e) {e.printStackTrace();};

}

//生成一�Ҏ(gu��)��件myprikey.dat和mypubkey.dat---�U�钥和公�?
//公钥要用户发�?文�g,�|�络�{�方�?�l�其它用�?�U�钥保存在本�?br />public boolean generatekey()
{
try {
java.security.KeyPairGenerator keygen=java.security.KeyPairGenerator.getInstance("DSA");
// SecureRandom secrand=new SecureRandom();
// secrand.setSeed("tttt".getBytes()); //初始化随��Z�生器
// keygen.initialize(576,secrand); //初始化密钥生成器
keygen.initialize(512);
KeyPair keys=keygen.genKeyPair();
// KeyPair keys=keygen.generateKeyPair(); //生成密钥�l?br />PublicKey pubkey=keys.getPublic();
PrivateKey prikey=keys.getPrivate();

java.io.ObjectOutputStream out=new java.io.ObjectOutputStream(new java.io.FileOutputStream("myprikey.dat"));
out.writeObject(prikey);
out.close();
System.out.println("写入对象 prikeys ok");
out=new java.io.ObjectOutputStream(new java.io.FileOutputStream("mypubkey.dat"));
out.writeObject(pubkey);
out.close();
System.out.println("写入对象 pubkeys ok");
System.out.println("生成密钥�Ҏ(gu��)��?);
return true;
}
catch (java.lang.Exception e) {
e.printStackTrace();
System.out.println("生成密钥对失�?);

return false;
};

}

public String byte2hex(byte[] b)
{
String hs="";
String stmp="";
for (int n=0;n {
stmp=(java.lang.Integer.toHexString(b[n] & 0XFF));
if (stmp.length()==1) hs=hs+"0"+stmp;
else hs=hs+stmp;
if (n }
return hs.toUpperCase();
}

}

2.4. DESede/DES对称��法
首先生成密钥,�q�保�?�q�里�q�没的保存的代码,可参考DSA中的�Ҏ(gu��)��)

KeyGenerator keygen = KeyGenerator.getInstance(Algorithm);

SecretKey deskey = keygen.generateKey();

用密钥加密明�?myinfo),生成密文(cipherByte)

Cipher c1 = Cipher.getInstance(Algorithm);

c1.init(Cipher.ENCRYPT_MODE,deskey);

byte[] cipherByte=c1.doFinal(myinfo.getBytes());

传送密文和密钥,本文没有相应代码可参考DSA

.............

用密钥解密密�?/p>
c1 = Cipher.getInstance(Algorithm);

c1.init(Cipher.DECRYPT_MODE,deskey);

byte[] clearByte=c1.doFinal(cipherByte);

相对来说对称密钥的��用是很简单的,对于JCE来讲支技DES,DESede,Blowfish三种加密�?/p>
对于密钥的保存各传送可使用对象��或者用二进制编�?相关参考代码如�?
SecretKey deskey = keygen.generateKey();
byte[] desEncode=deskey.getEncoded();
javax.crypto.spec.SecretKeySpec destmp=new javax.crypto.spec.SecretKeySpec(desEncode,Algorithm);
SecretKey mydeskey=destmp;

相关API

KeyGenerator 在DSA中已�l�说�?在添加JCE后在instance�q�可以如下参�?/p>
DES,DESede,Blowfish,HmacMD5,HmacSHA1

javax.crypto.Cipher �?解密�?public static final Cipher getInstance(java.lang.String transformation)
throws java.security.NoSuchAlgorithmException,
NoSuchPaddingException
�q�回一个指定方法的Cipher对象

参数:transformation �Ҏ(gu��)��?可用 DES,DESede,Blowfish)

public final void init(int opmode, java.security.Key key)
throws java.security.InvalidKeyException

用指定的密钥和模式初始化Cipher对象

参数pmode 方式(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE)

key 密钥

public final byte[] doFinal(byte[] input)
throws java.lang.IllegalStateException,
IllegalBlockSizeException,
BadPaddingException

对input内的�?�q�行�~�码处理,�q�回处理后二�q�制�?是返回解密文�q�是加解文由init时的opmode军_��

注意:本方法的执行前如果有update,是对updat和本�ơinput全部处理,否则是本inout的内�?/p>
/*
安全�E�序 DESede/DES��试
*/
import java.security.*;
import javax.crypto.*;
public class testdes {
public static void main(String[] args){
testdes my=new testdes();
my.run();
}
public void run() {
//��d��新安全算�?如果用JCE��p��把它��d��q�去
Security.addProvider(new com.sun.crypto.provider.SunJCE());
String Algorithm="DES"; //定义加密��法,可用 DES,DESede,Blowfish
String myinfo="要加密的信息";
try {
//生成密钥
KeyGenerator keygen = KeyGenerator.getInstance(Algorithm);
SecretKey deskey = keygen.generateKey();

//加密
System.out.println("加密前的二进�?"+byte2hex(myinfo.getBytes()));
System.out.println("加密前的信息:"+myinfo);
Cipher c1 = Cipher.getInstance(Algorithm);
c1.init(Cipher.ENCRYPT_MODE,deskey);
byte[] cipherByte=c1.doFinal(myinfo.getBytes());
System.out.println("加密后的二进�?"+byte2hex(cipherByte));
//解密
c1 = Cipher.getInstance(Algorithm);
c1.init(Cipher.DECRYPT_MODE,deskey);
byte[] clearByte=c1.doFinal(cipherByte);
System.out.println("解密后的二进�?"+byte2hex(clearByte));
System.out.println("解密后的信息:"+(new String(clearByte)));

}
catch (java.security.NoSuchAlgorithmException e1) {e1.printStackTrace();}
catch (javax.crypto.NoSuchPaddingException e2) {e2.printStackTrace();}
catch (java.lang.Exception e3) {e3.printStackTrace();}
}
public String byte2hex(byte[] b) //二行制�{字符�?br />{
String hs="";
String stmp="";
for (int n=0;n {
stmp=(java.lang.Integer.toHexString(b[n] & 0XFF));
if (stmp.length()==1) hs=hs+"0"+stmp;
else hs=hs+stmp;
if (n }
return hs.toUpperCase();
}

}

2.5. Diffie-Hellman密钥一致协�?
公开密钥密码体制的奠��Z�hDiffie和Hellman所提出�?"指数密钥一致协�?(Exponential Key Agreement Protocol),该协议不要求别的安全�?先决条�g,允许两名用户在公开媒体上交换信息以生成"一�?�?可以�׃�n的密钥。在JCE的中实现用户alice生成DH�c�d��的密钥对,如果长度�?024生成的时间请,推荐�W�一�ơ生成后保存DHParameterSpec,以便下次使用直接初始�?使其速度加快

System.out.println("ALICE: 产生 DH �?...");
KeyPairGenerator aliceKpairGen = KeyPairGenerator.getInstance("DH");
aliceKpairGen.initialize(512);
KeyPair aliceKpair = aliceKpairGen.generateKeyPair();

alice生成公钥发送组bob byte[] alicePubKeyEnc = aliceKpair.getPublic().getEncoded();

bob从alice发送来的公钥中��d��DH密钥对的初始参数生成bob的DH密钥�?/p>
注意�q�一步一定要�?要保证每个用��L(f��ng)��相同的初始参数生成的
DHParameterSpec dhParamSpec = ((DHPublicKey)alicePubKey).getParams();
KeyPairGenerator bobKpairGen = KeyPairGenerator.getInstance("DH");
bobKpairGen.initialize(dhParamSpec);
KeyPair bobKpair = bobKpairGen.generateKeyPair();

bob�Ҏ(gu��)��a(ch��n)lice的公钥生成本地的DES密钥
KeyAgreement bobKeyAgree = KeyAgreement.getInstance("DH");
bobKeyAgree.init(bobKpair.getPrivate());
bobKeyAgree.doPhase(alicePubKey, true);
SecretKey bobDesKey = bobKeyAgree.generateSecret("DES");

bob已经生成了他的DES密钥,他现把他的公钥发�l�alice,
byte[] bobPubKeyEnc = bobKpair.getPublic().getEncoded();

alice�Ҏ(gu��)��bob的公钥生成本地的DES密钥
,,,,,,解码
KeyAgreement aliceKeyAgree = KeyAgreement.getInstance("DH");
aliceKeyAgree.init(aliceKpair.getPrivate());
aliceKeyAgree.doPhase(bobPubKey, true);
SecretKey aliceDesKey = aliceKeyAgree.generateSecret("DES");

bob和alice能过�q�个�q�程��q��成了相同的DES密钥,在这�U�基��可�q�行安全能信

常用API

java.security.KeyPairGenerator 密钥生成器类
public static KeyPairGenerator getInstance(String algorithm)
throws NoSuchAlgorithmException
以指定的��法�q�回一个KeyPairGenerator 对象
参数: algorithm ��法�?�?原来是DSA,现在��d��?DiffieHellman(DH)

public void initialize(int keysize)
以指定的长度初始化KeyPairGenerator对象,如果没有初始化系�l�以1024长度默认讄��
参数:keysize ��法位长.其范围必��d�� 512 �?1024 之间�Q�且必须�?64 的倍数
注意:如果�?024生长的时间很�?最好生成一�ơ后��׃��?下次��׃��用生成了

public void initialize(AlgorithmParameterSpec params)
throws InvalidAlgorithmParameterException
以指定参数初始化

javax.crypto.interfaces.DHPublicKey
public DHParameterSpec getParams()
�q�回
java.security.KeyFactory

public static KeyFactory getInstance(String algorithm)
throws NoSuchAlgorithmException
以指定的��法�q�回一个KeyFactory
参数: algorithm ��法名SH,DH

public final PublicKey generatePublic(KeySpec keySpec)
throws InvalidKeySpecException
�Ҏ(gu��)��指定的key说明,�q�回一个PublicKey对象

java.security.spec.X509EncodedKeySpec
public X509EncodedKeySpec(byte[] encodedKey)
�Ҏ(gu��)��指定的二�q�制�~�码的字串生成一个key的说�?br />参数:encodedKey 二进制编码的字串(一般能�q�PublicKey.getEncoded()生成)
javax.crypto.KeyAgreement 密码一至类

public static final KeyAgreement getInstance(java.lang.String algorithm)
throws java.security.NoSuchAlgorithmException
�q�回一个指定算法的KeyAgreement对象
参数:algorithm ��法�?现在只能是DiffieHellman(DH)

public final void init(java.security.Key key)
throws java.security.InvalidKeyException
用指定的�U�钥初始�?br />参数:key 一个私�?/p>
public final java.security.Key doPhase(java.security.Key key,
boolean lastPhase)
throws java.security.InvalidKeyException,
java.lang.IllegalStateException
用指定的公钥�q�行定位,lastPhase��定�q�是否是最后一个公�?对于两个用户�?br />情况下就可以多次定次,最后确�?br />参数:key 公钥
lastPhase 是否最后公�?/p>
public final SecretKey generateSecret(java.lang.String algorithm)
throws java.lang.IllegalStateException,
java.security.NoSuchAlgorithmException,
java.security.InvalidKeyException
�Ҏ(gu��)��指定的算法生成密�?br />参数:algorithm 加密��法(可用 DES,DESede,Blowfish)

*/
import java.io.*;
import java.math.BigInteger;
import java.security.*;
import java.security.spec.*;
import java.security.interfaces.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import javax.crypto.interfaces.*;
import com.sun.crypto.provider.SunJCE;

public class testDHKey {

public static void main(String argv[]) {
try {
testDHKey my= new testDHKey();
my.run();
} catch (Exception e) {
System.err.println(e);

}
}

private void run() throws Exception {
Security.addProvider(new com.sun.crypto.provider.SunJCE());

System.out.println("ALICE: 产生 DH �?...");
KeyPairGenerator aliceKpairGen = KeyPairGenerator.getInstance("DH");
aliceKpairGen.initialize(512);
KeyPair aliceKpair = aliceKpairGen.generateKeyPair(); //生成旉��?

// 张三(Alice)生成公共密钥 alicePubKeyEnc �q�发送给李四(Bob) ,
//比如用文件方�?socket.....
byte[] alicePubKeyEnc = aliceKpair.getPublic().getEncoded();

//bob接收到alice的编码后的公�?��其解码
KeyFactory bobKeyFac = KeyFactory.getInstance("DH");
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec (alicePubKeyEnc);
PublicKey alicePubKey = bobKeyFac.generatePublic(x509KeySpec);
System.out.println("alice公钥bob解码成功");
// bob必须用相同的参数初始化的他的DH KEY�?所以要从Alice发给他的公开密钥,
//中读出参�?再用�q�个参数初始化他�?DH key�?/p>
//从alicePubKye中取alice初始化时用的参数
DHParameterSpec dhParamSpec = ((DHPublicKey)alicePubKey).getParams();
KeyPairGenerator bobKpairGen = KeyPairGenerator.getInstance("DH");
bobKpairGen.initialize(dhParamSpec);
KeyPair bobKpair = bobKpairGen.generateKeyPair();
System.out.println("BOB: 生成 DH key �Ҏ(gu��)��?);
KeyAgreement bobKeyAgree = KeyAgreement.getInstance("DH");
bobKeyAgree.init(bobKpair.getPrivate());
System.out.println("BOB: 初始化本地key成功");
//李四(bob) 生成本地的密�?bobDesKey
bobKeyAgree.doPhase(alicePubKey, true);
SecretKey bobDesKey = bobKeyAgree.generateSecret("DES");
System.out.println("BOB: 用alice的公钥定位本地key,生成本地DES密钥成功");
// Bob生成公共密钥 bobPubKeyEnc �q�发送给Alice,
//比如用文件方�?socket.....,使其生成本地密钥
byte[] bobPubKeyEnc = bobKpair.getPublic().getEncoded();
System.out.println("BOB向ALICE发送公�?);

// alice接收�?bobPubKeyEnc后生成bobPubKey
// 再进行定�?使aliceKeyAgree定位在bobPubKey
KeyFactory aliceKeyFac = KeyFactory.getInstance("DH");
x509KeySpec = new X509EncodedKeySpec(bobPubKeyEnc);
PublicKey bobPubKey = aliceKeyFac.generatePublic(x509KeySpec);
System.out.println("ALICE接收BOB公钥�q�解码成�?);
;
KeyAgreement aliceKeyAgree = KeyAgreement.getInstance("DH");
aliceKeyAgree.init(aliceKpair.getPrivate());
System.out.println("ALICE: 初始化本地key成功");

aliceKeyAgree.doPhase(bobPubKey, true);
// 张三(alice) 生成本地的密�?aliceDesKey
SecretKey aliceDesKey = aliceKeyAgree.generateSecret("DES");
System.out.println("ALICE: 用bob的公钥定位本地key,�q�生成本地DES密钥");

if (aliceDesKey.equals(bobDesKey)) System.out.println("张三和李四的密钥相同");
//现在张三和李四的本地的deskey是相同的所�?完全可以�q�行发送加�?接收后解�?辑ֈ�
//安全通道的的目的

/*
* bob用bobDesKey密钥加密信息
*/
Cipher bobCipher = Cipher.getInstance("DES");
bobCipher.init(Cipher.ENCRYPT_MODE, bobDesKey);
String bobinfo= "�q�是李四的机密信�?;
System.out.println("李四加密前原�?"+bobinfo);
byte[] cleartext =bobinfo.getBytes();
byte[] ciphertext = bobCipher.doFinal(cleartext);

/*
* alice用aliceDesKey密钥解密
*/
Cipher aliceCipher = Cipher.getInstance("DES");
aliceCipher.init(Cipher.DECRYPT_MODE, aliceDesKey);
byte[] recovered = aliceCipher.doFinal(ciphertext);
System.out.println("alice解密bob的信�?"+(new String(recovered)));
if (!java.util.Arrays.equals(cleartext, recovered))
throw new Exception("解密后与原文信息不同");
System.out.println("解密后相�?);

}

}

�W?�?��结

在加密术中生成密钥对�Ӟ��密钥对的当然是越长越好，但费时也��多�Q�请从中从实际出发选取合适的长度�Q�大部分例码中的密钥是每�ơ运行就从新生成�Q�在实际的情况中是生成后在一�D�|��间保存在文�g中，再次�q�行直接从文件中��d��Q�从而加快速度。当然定时更新和加强密钥保管的安全性也是必��ȝ��?br />

　

文章引用�? http://www.nihaoblog.com/1_1751.html

zeroone0 2006-04-03 09:55 发表评论

JAR文�g包及(qi��ng)jar命��o(h��)详解

zeroone0 — Mon, 03 Apr 2006 01:51:00 GMT
1. JAR 文�g包�?br />
　　JAR 文�g��是 Java Archive File�Q�顾名思意�Q�它的应用是与 Java 息息相关的，是 Java 的一�U�文档格式。JAR 文�g非常�c�M�� ZIP 文�g??准确的说�Q�它?y��u)��是 ZIP 文�g�Q�所以叫它文件包。JAR 文�g与 ZIP 文�g唯一的区别就是在 JAR 文�g的内容中�Q�包含了一个 META-INF/MANIFEST.MF 文�g�Q�这个文件是在生成 JAR 文�g的时候自动创建的。�D个例子，如果我们��h��如下目录�l�构的一些文�Ӟ��(x��)

　　==

　　`-- test

　　　 `-- Test.class

　　把它压羃成 ZIP 文�g test.zip�Q�则�q�个 ZIP 文�g的内部目录结构�ؓ(f��)�Q��?br />
　　test.zip

　　`-- test

　　　 `-- Test.class

　　如果我们使用 JDK 的 jar 命��o(h��)把它打成 JAR 文�g包 test.jar�Q�则�q�个 JAR 文�g的内部目录结构�ؓ(f��)�Q��?br />
　　test.jar

　　|-- META-INF

　　|　 `-- MANIFEST.MF

　　`-- test

　　　　`--Test.class

　　2. 创徏可执行的 JAR 文�g包�?br />
　　制作一个可执行的 JAR 文�g包来发布你的�E�序是 JAR 文�g包最典型的用法。�?br />
　　Java �E�序是由若干个�?class 文�g�l�成的。这些�?class 文�g必须�Ҏ(gu��)��它们所属的包不同而分�U�分目录存放�Q�运行前需要把所有用到的包的根目录指定给 CLASSPATH 环境变量或者 java 命��o(h��)的�?cp 参数�Q�运行时�q�要到控制台下去使用 java 命��o(h��)来运行，如果需要直接双击运行必��d�� Windows 的批处理文�g (.bat) 或者 Linux 的 Shell �E�序。因此，许多��Q�Java 是一�U�方便开发者苦了用��L(f��ng)��E�序设计语言。�?br />
　　其实不然�Q�如果开发者能够制作一个可执行的 JAR 文�g包交�l�用��P��那么用户使用��h��方便了。在 Windows 下安装 JRE (Java Runtime Environment) 的时候，安装文�g�?x��)将�?jar 文�g映射�l� javaw.exe 打开。那么，对于一个可执行的 JAR 文�g包，用户只需要双��d��?y��u)��可以运行程序了�Q�和阅读 .chm 文档一��h��便�?.chm 文档默认是由 hh.exe 打开�?。那么，现在的关键，��是如何来创��个可执行的 JAR 文�g包。�?br />
　　创徏可执行的 JAR 文�g包，需要��用带 cvfm 参数的 jar 命��o(h��)�Q�同样以上述 test 目录��Z��Q�命令如下：(x��)

jar cvfm test.jar manifest.mf test

　　�q�里 test.jar 和 manifest.mf 两个文�g�Q�分别是对应的参敊W�f 和 m�Q�其重头戏在 manifest.mf。因��创徏可执行的 JAR 文�g包，光靠指定一个 manifest.mf 文�g是不够的�Q�因为 MANIFEST 是 JAR 文�g包的特征�Q�可执行的 JAR 文�g包和不可执行的 JAR 文�g包都包含 MANIFEST。关键在于可执行 JAR 文�g包的 MANIFEST�Q�其内容包含了 Main-Class 一��V��这在 MANIFEST 中书写格式如下：(x��)

　　Main-Class: 可执行主�c�d��?包含包名)

　　例如�Q�假设上例中的 Test.class 是属于 test 包的�Q�而且是可执行的类 (定义了 public static void main(String[]) �Ҏ(gu��)��)�Q�那么这个 manifest.mf 可以�~�辑如下�Q��?br />
Main-Class: test.Test <回�R>

　　�q�个 manifest.mf 可以攑֜��M��位置�Q�也可以是其它的文�g名，只需要有 Main-Class: test.Test 一行，且该行以一个回车符�l�束卛_��。创��Z�� manifest.mf 文�g之后�Q�我们的目录�l�构变�ؓ(f��)�Q��?br />
　　==

　　|-- test

　　|　 `-- Test.class

　　`-- manifest.mf

　　�q�时候，需要到 test 目录的上�U�目录中��M��用 jar 命��o(h��)来创建 JAR 文�g包。也��是在目录树(w��i)中��用�?=”表�C�的那个目录中，使用如下命��o(h��)�Q��?br />
jar cvfm test.jar manifest.mf test

　　之后在�?=”目录中创徏了 test.jar�Q�这个 test.jar ��是执行的 JAR 文�g包。运行时只需要��用 java -jar test.jar 命��o(h��)卛_��。�?br />
　　需要注意的是，创徏的 JAR 文�g包中需要包含完整的、与 Java �E�序的包�l�构对应的目录结构，��像上例一栗��而 Main-Class 指定的类�Q�也必须是完整的、包含包路径的类名，如上例的 test.Test�Q�而且在没有打成 JAR 文�g包之前可以��用 java <�c�d��> 来运行这个类�Q�即在上例中 java test.Test 是可以正��运行的 (当然要在 CLASSPATH 正确的情况下)�?br />
　　3. jar 命��o(h��)详解

　　jar 是随 JDK 安装的，在 JDK 安装目录下的 bin 目录中，W(xu��)indows 下文件名为 jar.exe�Q�Linux 下文件名为 jar。它的运行需要用刊W�JDK 安装目录下 lib 目录中的 tools.jar 文�g。不�q�我们除了安装 JDK 什么也不需要做�Q�因为 SUN 已经帮我们做好了。我们甚至不需要将 tools.jar 攑ֈ� CLASSPATH 中。�?br />
　　使用不带��M��的 jar 命��o(h��)我们可以看到 jar 命��o(h��)的用法如下：(x��)

　　jar {ctxu}[vfm0M] [jar-文�g] [manifest-文�g] [-C 目录] 文�g名�?..

　　其中 {ctxu} 是 jar 命��o(h��)的子命��o(h��)�Q�每�ơ jar 命��o(h��)只能包含 ctxu 中的一个，它们分别表示�Q��?br />
　　　-c　创徏新的 JAR 文�g包�?br />
　　　-t　列出 JAR 文�g包的内容列表

　　　-x　展开 JAR 文�g包的指定文�g或者所有文件�?br />
　　　-u　更新已存在的 JAR 文�g包�?��d��文�g刊W�JAR 文�g包中)

　　　　　[vfm0M] 中的选项可以任选，也可以不选，它们是 jar 命��o(h��)的选项参数

　　　-v　生成详细报告�q�打印到标准输出

　　　-f　指定 JAR 文�g名，通常�q�个参数是必��ȝ��

　　　-m　指定需要包含的 MANIFEST 清单文�g

　　　-0　只存储，不压�~�，�q�样产生的 JAR 文�g包会(x��)比不用该参数产生的体�U�大�Q�但速度更快

　　　-M　不��生所有项的清单（MANIFEST〕文�Ӟ��此参��C��(x��)忽略 -m 参数

　　　　　[jar-文�g] 即需要生成、查看、更新或者解开的 JAR 文�g包，它是 -f 参数的附属参敊W?br />
　　　　　[manifest-文�g] �ꐠMANIFEST 清单文�g�Q�它是�?m 参数的附属参敊W?br />
　　　　　[-C 目录] 表示转到指定目录下去执行�q�个 jar 命��o(h��)的操作。它相当于先使用 cd 命��o(h��)转该目录下再执行不带 -C 参数的 jar 命��o(h��)�Q�它只能在创建和更新 JAR 文�g包的时候可用。　　

　　文�g名�?.. 指定一个文�?目录列表�Q�这些文�?目录��是要添加到 JAR 文�g包中的文�?目录。如果指定了目录�Q�那么 jar 命��o(h��)打包的时候会(x��)自动把该目录中的所有文件和子目录打入包中。�?br />
　　下面举一些例子来说明 jar 命��o(h��)的用法：(x��)

　　1) jar cf test.jar test

　　该命令没有执行过�E�的昄��Q�执行结果是在当前目录生成了 test.jar 文�g。如果当前目录已�l�存在 test.jar�Q�那么该文�g��被覆盖。�?br />
　　2) jar cvf test.jar test

　　该命令与上例中的�l�果相同�Q�但是由于 v 参数的作用，昄��Z��打包�q�程�Q�如下：(x��)

　　标明清单(manifest)

　　增加�Q�test/(��d��= 0) (写出= 0)(存储了�?%)

　　增加�Q�test/Test.class(��d��= 7) (写出= 6)(压羃了�?4%)

　　3) jar cvfM test.jar test

　　该命令与 2) �l�果�c�M��Q�但在生成的 test.jar 中没有包含 META-INF/MANIFEST 文�g�Q�打包过�E�的信息也略有差别：(x��)

　　增加�Q�test/(��d��= 0) (写出= 0)(存储了�?%)

　　增加�Q�test/Test.class(��d��= 7) (写出= 6)(压羃了�?4%)

　　4) jar cvfm test.jar manifest.mf test

　　�q�行�l�果与�?) �怼��Q�显�C�Z��息也相同�Q�只是生成 JAR 包中的 META-INF/MANIFEST 内容不同�Q�是包含了 manifest.mf 的内容�?br />
　　5) jar tf test.jar

　　在 test.jar 已经存在的情况下�Q�可以查看 test.jar 中的内容�Q�如对于 2) 和�?) 生成的 test.jar 分别应该此命令，�l�果如下�Q��?br />
　　对于 2)

　　META-INF/

　　META-INF/MANIFEST.MF

　　test/

　　test/Test.class

　　对于 3)

　　test/

　　test/Test.class

　　6) jar tvf test.jar

　　除显�C��?) 中显�C�的内容外，�q�包括包内文件的详细信息�Q�如�Q��?br />
　　0 Wed Jun 19 15:39:06 GMT 2002 META-INF/

　　86 Wed Jun 19 15:39:06 GMT 2002 META-INF/MANIFEST.MF

　　0 Wed Jun 19 15:33:04 GMT 2002 test/

　　7 Wed Jun 19 15:33:04 GMT 2002 test/Test.class

　　7) jar xf test.jar

　　解开 test.jar 到当前目录，不显�C�Z�Q何信息，对于 2) 生成的 test.jar�Q�解开后的目录�l�构如下�Q��?br />
　　==

　　|-- META-INF

　　|　 `-- MANIFEST

　　`-- test

　　　　`--Test.class

jar xvf test.jar

　　�q�行�l�果与�?) 相同�Q�对于解压过�E�有详细信息昄��Q�如�Q��?br />
　　创徏�Q�META-INF/

　　展开�Q�META-INF/MANIFEST.MF

　　创徏�Q�test/

　　展开�Q�test/Test.class

　　9) jar uf test.jar manifest.mf

　　在 test.jar 中添加了文�g manifest.mf�Q�此使用 jar tf 来查看 test.jar 可以发现 test.jar 中比原来多了一个 manifest。这里顺便提一下，如果使用 -m 参数�q�指定 manifest.mf 文�g�Q�那么 manifest.mf 是作为清单文件 MANIFEST 来��用的�Q�它的内容会(x��)被添加到 MANIFEST 中；但是�Q�如果作��Z��般文件添加到 JAR 文�g包中�Q�它跟一般文件无异。�?br />
　　10) jar uvf test.jar manifest.mf

　　与�?) �l�果相同�Q�同时有详细信息昄��Q�如�Q��?br />
　　增加�Q�manifest.mf(��d��= 17) (写出= 19)(压羃了�?11%)

　　4. 关于 JAR 文�g包的一些技巧�?br />
　　1) 使用 unzip 来解压 JAR 文�g

　　在介�l� JAR 文�g的时候就已经说过了，JAR 文�g实际上就是 ZIP 文�g�Q�所以可以��用常见的一些解压 ZIP 文�g的工��h��解压 JAR 文�g�Q�如 Windows 下的 WinZip、WinRAR �{�和 Linux 下的 unzip �{�。��用 WinZip 和 WinRAR �{�来解压是因为它们解压比较直观，方便。而��用 unzip�Q�则是因为它解压时可以��用�?d 参数指定目标目录。�?br />
　　在解压一个 JAR 文�g的时候是不能使用 jar 的�?C 参数来指定解压的目标的，因�ؓ(f��) -C 参数只在创徏或者更新包的时候可用。那么需要将文�g解压到某个指定目录下的时候就需要先��这具 JAR 文�g拯��到目标目录下�Q�再�q�行解压�Q�比较麻烦。如果��用 unzip�Q�就不需要这么麻烦了�Q�只需要指定一个�?d 参数卛_��。如�Q��?br />
　　unzip test.jar -d dest/

　　2) 使用 WinZip 或者 WinRAR �{�工具创建 JAR 文�g

　　上面提到 JAR 文�g��是包含了 META-INF/MANIFEST 的 ZIP 文�g�Q�所以，只需要��用 WinZip、WinRAR �{�工具创建所需要 ZIP 压羃包，再往�q�个 ZIP 压羃包中��d��一个包含 MANIFEST 文�g的 META-INF 目录卛_��。对于��用 jar 命��o(h��)的�?m 参数指定清单文�g的情况，只需要将�q�个 MANIFEST 按需要修改即可。�?br />
　　3) 使用 jar 命��o(h��)创徏 ZIP 文�g

　　有些 Linux 下提供了 unzip 命��o(h��)�Q�但没有 zip 命��o(h��)�Q�所以需要可以对 ZIP 文�g�q�行解压�Q�即不能创徏 ZIP 文�g。如要创��Z��个 ZIP 文�g�Q��用带 -M 参数的 jar 命��o(h��)卛_��Q�因为�?M 参数表示制作 JAR 包的时候不��d�� MANIFEST 清单�Q�那么只需要在指定目标 JAR 文�g的地方将 .jar 扩展名改为�?zip 扩展名，创徏的就是一个不折不扣的 ZIP 文�g了，如将上一节的�W��?) 个例子略作改动：(x��)

　　jar cvfM test.zip test

文章引用�? http://www.javaresearch.org/article/showarticle.jsp?column=1&thread=32683

zeroone0 2006-04-03 09:51 发表评论

Java Mail�~�程

zeroone0 — Mon, 03 Apr 2006 01:49:00 GMT

1.介绍:

Java Mail API的开发是SUN为Java开发者提供公用API框架的持�l�努力的良好例证。提倡公用框�Ӟ��反对受限于供应商的解��x��案，充分预示着一个日益开攄��开发环境的建立�?br />　　Java Mail API的结构本�w�证明了它的开发者的基本目标之一--软�g开发的工作量应该取决于应用�E�序本��n的复杂程度以�?qi��ng)开发者所要求的控制程度。换句话��_(d��)��Java Mail API��可能地保持��单。乍看�v来，JavaMail API所拥有的类��L��以及(qi��ng)�c�M��间的关系可能让�h误解��p��漫长的学�?f��n)时间。实际上�Q�一旦正式开始��用，你就�?x��)发现该API不失为在应用�E�序中加入健壮的邮�g/通讯支持的简单工兗��?

2.安装:

安装前要��保你的机子上安装得有标准版的JDK和W(xu��)eb服务�?�q�且已配�|�好,有关它们的安装方�?请参考其它文�?�|�上到处都有).

(1).安装JavaMail API。现在最常用�?JavaMail API 版本�?.3.
　　要��?JavaMail 1.3 API�Q�请下蝲 JavaMail 1.3 实现�Q�解开Javamail-1_3.zip 文�g�Q��ƈ��?mail.jar 文�g��d��?CLASSPATH 中。除了核心类�Q�随版本 1.3 实现一��h��供的�q�有 SMTP、IMAP4 �?POP3 供应商�?br />　　
(2).JavaBeans Activation Framework(1.0.2�? 的安�?br />JavaMail API 的所有版本都需�?JavaBeans Activation Framework 来支持�Q意数据块的输入及(qi��ng)相应处理。功能似乎不多，但目前许多浏览器和邮件工具中都能扑ֈ��q�种基本�?MIME 型支持。下载完框架后，解开 jaf1_0_2.zip 文�g�Q��ƈ��?activation.jar 文�g��d��?CLASSPATH 中�?br />　　

�? 如果�(zh��n)��用的JDK是J2EE�Q�就没有什么特定的事非要用基本 JavaMail API来做不可�Q�J2EE 的类��p��处理�?因�ؓ(f��)它本�w�就包含有JavaMail API和JAF,�(zh��n)�只需要确��?j2ee.jar 文�g��d��到�?zh��n)�的CLASSPATH 中�ƈ已全部设�|�好�?br />
3.JavaMail的常用类介绍

事先说明:

没用�q�JavaMail的�h可能看不懂这些介�l?不过不要�?后面的文章有具体的实�?到时也可倒回来查看这些类的用�?

(1) javax.mail.Properties�c?br />　　JavaMail需要Properties来创��Z��个session对象。它?y��u)��寻扑֭��W�串"mail.smtp.host"�Q�属性值就是发送邮件的��L��.

用法:
　Properties props = new Properties ();
　　　props.put("mail.smtp.host", "smtp.163.com");//可以换上你的smtp��L��名�?br />

(2) javax.mail.Session�c?br />　　�q�个Session�c�M��表JavaMail 中的一个邮件session. 每一个基�?JavaMail的应用程序至��有一个session但是可以有�Q意多的session�?在这个例子中, Session对象需要知道用来处理邮件的SMTP 服务器�?br />
用法:
　　 Session sendMailSession;
　　 sendMailSession = Session.getInstance(props, null);

(3) javax.mail.Transport�c?br />　　邮�g是既可以被发送也可以被受到。JavaMail使用了两个不同的�c�L��完成�q�两个功能：(x��)Transport 和Store. Transport 是用来发送信息的�Q�而Store用来收信。对于这的教�E�我们只需要用到Transport对象�?br />
用法�Q?br />Transport transport;
　 transport = sendMailSession.getTransport("smtp");

　　用JavaMail Session对象的getTransport �Ҏ(gu��)��来初始化Transport。传�q�去的字�W�串��x��了对象所要��用的协议�Q�如"smtp"。这��ؓ(f��)我们省了很多旉��。因为JavaMail以境内置了很多协议的实现�Ҏ(gu��)��?br />
　注意: JavaMail�q�不是绝�Ҏ(gu��)��持每一个协议，目前支持IMAP�?SMTP�?POP3.

(4) javax.mail.MimeMessage�c?br />　　Message对象��存储我们实际发送的�?sh��)子邮�g信息�Q�Message对象被作��Z��个MimeMessage对象来创建�ƈ且需要知道应当选择哪一个JavaMail session�?br />
　　用法�Q?br />Message newMessage = new MimeMessage(sendMailSession);

(5) javax.mail.InternetAddress�c?br />一旦�?zh��n)�创徏�?Session �?Message�Q��ƈ��内容填入消息后�Q�就可以用Address��定信�g地址了。和 Message 一��P��Address 也是个抽象类。�?zh��n)�用的是Javax.mail.internet.InternetAddress �c?

用法:
InternetAddress from=new InternetAddress("xxf@cafe.com");

(6) javax.mail.Store�c?br />Store�c�d��现特定邮件协议上的读、写、监视、查扄��操作。通过Javax.mail.Store�c�d��以访问Javax.mail.Folder�c�R�?br />
用法:
Store store=s.getSorte("pop3");//s��Z��个邮件会(x��)�?br />store.connect(popserver,username,password);//通过你提供的pop地址,用户名和密码��d��你的邮箱

(7) javax.mail.Folder�c?br />Folder�cȝ��于分�U�组�l�邮�Ӟ��q�提供照Javax.mail.Message格式讉K��email的能力�?

用法:
Folder folder=store.getFolder("INBOX");
folder.open(Folder.READ_ONLY);

(8) javax.mail.Internet.MimeMultpart
一般保存电(sh��)子邮件内容的容器是Multipart抽象�c?它定义了增加和删除及(qi��ng)获得�?sh��)子邮�g不同部分内容的方�?�׃��Multipart是抽象类,我们必须为它使用一个具体的子类,JavaMail API提供javax.mail.Internet.MimeMultpart�c�L��使用MimeMessage对象.

用法:
MimeMultipart multipart=new MimeMultipart();

�?我们使用MimeMultipart对象的一个方法是addBodyPart(),它在我们的电(sh��)子邮件内定w��d��BodyPart(BodyPart�c�d��下面紧接着要介�l?对象.消息可以有很多部�?一个BodyPart可以代表一个部�?

(9) javax.mail.Internet.MimeBodyPart�c?br />
MimeBodyPart是BodyPart具体用于mimeMessage的一个子�c?
MimeBodyPart对象代表一个MimeMessage对象内容的一部分.每个MimeBodyPart被认为有两部�?
⊙一个MIME�c�d��
⊙匹配这个类型的内容

用法:
MimeBodyPart mdp=new MimeBodyPart();
String text="Hello JavaMail!";
mdp.setContent(text,"text/plain");//定义MIME�c�d��为text/plain,�q�设�|�MimeBodyPart的内�?

(10) javax.activation.DataHandler�c?包含在JAF�?
JavaMail API不限制信息只为文�?��M��形式的信息都可能作茧(d��o)自缚(x��)MimeMessage的一部分.除了文本信息,作�ؓ(f��)文�g附�g包含在电(sh��)子邮件信息的一部分是很普遍�?JavaMail API通过使用DataHandler对象,提供一个允许我们包含非文本BodyPart对象的简便方�?

用法:
DataHandler dh=new DataHandler(text,type);
mdp.setDatahandler(dh);//mdp是一个MimeBodyPart对象

(11) javax.activation.FileDataSource�c?包含在JAF�?
一个FileDataSource对象可以表示本地文�g和服务器可以直接讉K��的资�?一个本地文件可以通过创徏一个新的MimeBodyPart对象附在一个mimeMessage对象�?

用法:
MimeMultipart mm=new MimeMultipart();
MimeBodyPart mdp=new MimeBodyPart();
FileDataSource fds=new FileDataSource("c:/exam.txt");
mdp.setDataHandler(new DataHandler(fds)); //讄��数据�?br />mm.addBodyPart(mdp); //为当前消息MimeMultipart对象增加MimeBodyPart

(12) javax.activation.URLDataSource�c?包含在JAF�?
�q�程资源,URL不会(x��)指向它们,�׃��个URLDataSource对象表示.一个远�E�资源可以通过创徏一个新mimeBodyPart对象附在一个mimeMessage对象�?同FileDataSource差不�?.

用法:
与FileDataSource唯一不同的是数据源的讄��:
URLDataSource uds=new URLDataSource(http://www.cnjsp.com/logo.gif);

4.试着�~�写�W�一个发送程�?/div>
在前面我们已对JavaMail作了一些介�l?下面我们可试着写自��q��E�序�?
首先,我们先写一个撰写邮件的html�E�序index.htm,如下:
-------------------------------------------------------------------------------------------

撰写邮�g

收信人地址:
主题:

接着,我们再写一个处理程序testmail.jsp,如下:
-----------------------------------------------------------------------------------------
<%@ page contentType="text/html;charset=GB2312" %>
<%request.setCharacterEncoding("gb2312");%>

<%@ page import="java.util.*,javax.mail.*"%>
<%@ page import="javax.mail.internet.*"%>

发送成�?lt;/title><br /></head></div><div><body><br /><%<br />try{</div><div>//从html表单中获取邮件信�?br />String tto=request.getParameter("to");<br />String ttitle=request.getParameter("title");<br />String tcontent=request.getParameter("content");</div><div>Properties props=new Properties();//也可用Properties props = System.getProperties(); <br />props.put("mail.smtp.host","smtp.163.net");//存储发送邮件服务器的信�?br />props.put("mail.smtp.auth","true");//同时通过验证<br />Session s=Session.getInstance(props);//�Ҏ(gu��)��属性新��Z��个邮件会(x��)�?br />s.setDebug(true);</div><div>MimeMessage message=new MimeMessage(s);//由邮件会(x��)话新��Z��个消息对�?/div><div>//讄��邮�g<br />InternetAddress from=new InternetAddress("<a href="mailto:boy@163.net"><font color="#000033">boy@163.net</font></a>");<br />message.setFrom(from);//讄��发�g�?br />InternetAddress to=new InternetAddress(tto);<br />message.setRecipient(Message.RecipientType.TO,to);//讄��收�g�?�q�设�|�其接收�c�d��为TO<br />message.setSubject(ttitle);//讄��主题<br />message.setText(tcontent);//讄��信�g内容<br />message.setSentDate(new Date());//讄��发信旉��</div><div>//发送邮�?br />message.saveChanges();//存储邮�g信息<br />Transport transport=s.getTransport("smtp");<br />transport.connect("smtp.163.net","boy","iloveyou");//以smtp方式��d��邮箱<br />transport.sendMessage(message,message.getAllRecipients());//发送邮�?其中�W�二个参数是所�?br />//已设好的收�g人地址<br />transport.close();</div><div>%><br /><div align="center"><br /><p><font color="#FF6600">发送成�?</font></p><br /><p><a href="recmail.jsp">�ȝ��看我的信��?lt;/a><br><br /><br><br /><a href="index.htm">再发一��?lt;/a> </p><br /></div><br /><%<br />}catch(MessagingException e){<br />out.println(e.toString());<br />}<br />%><br /></body><br /></html></div><div>**********************************注意***************************************</div><div>有好多书上和�|�上的文章在关键部分都是�q�样写testmail.jsp�?如下:</div><div>String tto=request.getParameter("to");<br />String ttitle=request.getParameter("title");<br />String tcontent=request.getParameter("content");<br />Properties props=new Properties();<br />props.put("mail.smtp.host","smtp.163.net");<br />Session s=Session.getInstance(props);<br />MimeMessage message=new MimeMessage(s);</div><div>InternetAddress from=new InternetAddress("<a href="mailto:boy@163.net"><font color="#000033">boy@163.net</font></a>");<br />message.setFrom(from);<br />InternetAddress to=new InternetAddress(tto);<br />message.setRecipient(Message.RecipientType.TO,to);</div><div>message.setSubject(ttitle);<br />message.setText(tcontent);<br />message.setSentDate(new Date());</div><div>Store store=s.getStore("pop3");<br />store.connect("pop.163.net","boy","iloveyou");//以pop3的方式登录邮��?br />Transport transport=s.getTransport("smtp");<br />transport.send(message);<br />store.close();</div><div>事实�?�q�种方式�q�不可靠,因�ؓ(f��)很多�?sh��)子邮局的smtp服务器要求我们通过验证,所以用�q�种方式发邮件时,只能发给同类邮箱(即相同smtp的邮��?,甚至有时同类邮箱也发不出�?以上两种方式我试�q�很多次,�l�果证明�W�一�U�方式是最可靠�?</div><div><br />好了,我相信你应该�?x��)写最��单的Email发送程序了.OK,下一�ơ我们将说说怎样写发送HTML格式的邮�?</div><div>5.发送HTML格式的邮�?/div><div>所谓HTML格式,��是��文本格�?你的邮�g可以用HTML代码�~�写,发给�Ҏ(gu��)��?�Ҏ(gu��)��收到的将是信息将是超文本,��文本比�U�文本好看多�?下以面是在以前例子的基础上修改的�E�序:</div><div><%@ page contentType="text/html;charset=GB2312" %><br /><%request.setCharacterEncoding("gb2312");%><br /><%@ page import="java.util.*,javax.mail.*"%><br /><%@ page import="javax.mail.internet.*"%><br /><html><br /><head><br /><meta http-equiv="Content-Type" content="text/html; charset=gb2312"><br /><title>发送成�?lt;/title><br /></head></div><div><body><br /><%<br />try{<br />String tto=request.getParameter("to");<br />String ttitle=request.getParameter("title");<br />String tcontent=request.getParameter("content");<br />Properties props=new Properties();<br />props.put("mail.smtp.host","127.0.0.1");<br />props.put("mail.smtp.auth","true");<br />Session s=Session.getInstance(props);<br />s.setDebug(true);</div><div>MimeMessage message=new MimeMessage(s);</div><div>//�l�消息对象设�|�发件�h/收�g�?主题/发信旉��<br />InternetAddress from=new InternetAddress("<a href="mailto:xxf@cafe.com"><font color="#000033">xxf@cafe.com</font></a>");<br />message.setFrom(from);<br />InternetAddress to=new InternetAddress(tto);<br />message.setRecipient(Message.RecipientType.TO,to);<br />message.setSubject(ttitle);<br />message.setSentDate(new Date());</div><div><br />//�l�消息对象设�|�内�?br />BodyPart mdp=new MimeBodyPart();//新徏一个存放信件内容的BodyPart对象<br />mdp.setContent(tcontent,"text/html;charset=gb2312");//�l�BodyPart对象讄��内容和格�?�~�码方式<br />Multipart mm=new MimeMultipart();//新徏一个MimeMultipart对象用来存放BodyPart�?br />//�?事实上可以存攑֤��?<br />mm.addBodyPart(mdp);//��BodyPart加入到MimeMultipart对象�?可以加入多个BodyPart)<br />message.setContent(mm);//把mm作�ؓ(f��)消息对象的内�?/div><div>message.saveChanges();<br />Transport transport=s.getTransport("smtp");<br />transport.connect("127.0.0.1","xxf","coffee");<br />transport.sendMessage(message,message.getAllRecipients());<br />transport.close();<br />%><br /><div align="center"><br /><p><font color="#FF6600">发送成�?</font></p><br /><p><a href="recmail.jsp">�ȝ��看我的信��?lt;/a><br><br /><br><br /><a href="index.htm">再发一��?lt;/a> </p><br /></div><br /><%<br />}catch(MessagingException e){<br />out.println(e.toString());<br />}<br />%><br /></body><br /></html</div><div>6.发送三�U�类型的附�g</div><div>前面我们已学�?x��)了发送一般文本邮件和��文本邮�?今天我们��让大家学会(x��)�~�写三种�c�d��的附件的邮�g <br />发送程�?(�?撰写界面仍然用前面的)</div><div><%@ page contentType="text/html;charset=GB2312" %><br /><%request.setCharacterEncoding("gb2312");%><br /><%@ page import="java.util.*,javax.mail.*"%><br /><%@ page import="javax.mail.internet.*"%><br /><%@ page import="javax.activation.*"%><!--要发送附件必��d��入该�?-><br /><%@ page import="java.net.*"%><!--要用到URL�c?-><br /><html><br /><head><br /><meta http-equiv="Content-Type" content="text/html; charset=gb2312"><br /><title>发送成�?lt;/title><br /></head><br /><body><br /><%<br />try{<br />String tto=request.getParameter("to");<br />String ttitle=request.getParameter("title");<br />String tcontent=request.getParameter("content");<br />Properties props=new Properties();<br />props.put("mail.smtp.host","127.0.0.1");<br />props.put("mail.smtp.auth","true");<br />Session s=Session.getInstance(props);<br />s.setDebug(true);</div><div>MimeMessage message=new MimeMessage(s);</div><div>//�l�消息对象设�|�发件�h/收�g�?主题/发信旉��<br />InternetAddress from=new InternetAddress("<a href="mailto:xxf@cafe.com"><font color="#000033">xxf@cafe.com</font></a>");<br />message.setFrom(from);<br />InternetAddress to=new InternetAddress(tto);<br />message.setRecipient(Message.RecipientType.TO,to);<br />message.setSubject(ttitle);<br />message.setSentDate(new Date());</div><div>Multipart mm=new MimeMultipart();//新徏一个MimeMultipart对象用来存放多个BodyPart对象</div><div>//讄��信�g文本内容<br />BodyPart mdp=new MimeBodyPart();//新徏一个存放信件内容的BodyPart对象<br />mdp.setContent(tcontent,"text/html;charset=gb2312");//�l�BodyPart对象讄��内容和格�?�~�码方式<br />mm.addBodyPart(mdp);//��含有信件内容的BodyPart加入到MimeMultipart对象�?/div><div>//讄��信�g的附�?(自定义附�?直接��所设文本内容加到自定义文�g中作为附件发�?<br />mdp=new MimeBodyPart();//新徏一个存��N��件的BodyPart<br />DataHandler dh=new DataHandler("JavaMail附�g��试","text/plain;charset=gb2312");<br />//新徏一个DataHandler对象,�q�设�|�其内容和格�?�~�码方式<br />mdp.setFileName("xxf.txt");//加上�q�句��作为附件发�?否则��作��Z��件的文本内容<br />mdp.setDataHandler(dh);//�l�BodyPart对象讄��内容为dh<br />mm.addBodyPart(mdp);//��含有附件的BodyPart加入到MimeMultipart对象�?/div><div>//讄��信�g的附�?(用本��C��的文件作为附�?<br />mdp=new MimeBodyPart();<br />FileDataSource fds=new FileDataSource("g:/xx.txt");<br />dh=new DataHandler(fds);<br />mdp.setFileName("dd.txt");//可以和原文�g名不一�?br />mdp.setDataHandler(dh);<br />mm.addBodyPart(mdp);</div><div>//讄��信�g的附�?(用远�E�文件作为附�?<br />mdp=new MimeBodyPart();<br />URLDataSource ur=new URLDataSource(new URL("<a href="http://localhost:8080/jspstudy/email/xx.gif"><font color="#000033">http://localhost:8080/jspstudy/email/xx.gif</font></a>")); <br />//�?�q�里用的参数只能为URL对象,不能为URL字串,在前面类介绍时有�?误��?,�q�里�U�正一�?<br />dh=new DataHandler(ur);<br />mdp.setFileName("ss.txt");<br />mdp.setDataHandler(dh);<br />mm.addBodyPart(mdp);</div><div>message.setContent(mm);//把mm作�ؓ(f��)消息对象的内�?/div><div>message.saveChanges();<br />Transport transport=s.getTransport("smtp");<br />transport.connect("127.0.0.1","xxf","coffee");<br />transport.sendMessage(message,message.getAllRecipients());<br />transport.close();<br />%><br /><div align="center"><br /><p><font color="#FF6600">发送成�?</font></p><br /><p><a href="recmail.jsp">�ȝ��看我的信��?lt;/a><br><br /><br><br /><a href="index.htm">再发一��?lt;/a> </p><br /></div><br /><%<br />}catch(MessagingException e){<br />out.println(e.toString());<br />}<br />%><br /></body><br /></html></div><div>�?�~�写灉|��的发送程�?/div><div>本小节没加什么新鲜的东西,但是�l�合了以前的所有内�?可以让你灉|��地发送你惌��发的邮�g.看了本小节之后对你会(x��)感觉到非常有�?</div><div>更改后的撰写界面�E�序如下:<br />-------------------------------------------------------------------------------------------<br /><html><br /><head><br /><meta http-equiv="Content-Type" content="text/html; charset=gb2312"><br /><title>撰写邮�g

收信人地址:
主题:
信�g�c�d��

附�g1(自定�?:

(输入文本信息)
附�g2(本地):
附�g3(�q�程):

(输入URL)

处理邮�g的JSP�E�序如下:
----------------------------------------------------------------------------------------
<%@ page contentType="text/html;charset=GB2312" %>
<%request.setCharacterEncoding("gb2312");%>
<%@ page import="java.util.*,javax.mail.*"%>
<%@ page import="javax.mail.internet.*"%>
<%@ page import="javax.activation.*"%>

收信人地址:
主题:
信�g�c�d��

附�g1(自定�?: (输入文本信息)
附�g2(本地):
附�g3(�q�程): (输入URL)

亚洲成a人片在线观看日本麻豆 ,亚洲无人区视频大全,国产精品亚洲成在人线

jxl的一些�ȝ��

JAVA生成EXCEL文�g

Java Annotation

log4j日志���理

java 1.5

jsp��面中的下蝲功能实现

Web文�g的ContentType�c�d��

JAR文�g包及(qi��ng)jar命��o(h��)详解

Java Mail�~�程

log4j日志��理