JDK6的新特性

 

JDK6的新特性

关键字: jdk

JDK6的新特性
JDK6的新特性之一_Desktop类和SystemTray类
JDK6的新特性之七_用Console开发控制台程序
JDK6的新特性之三_理解StAX
JDK6的新特性之九_CommonAnnotations
JDK6的新特性之二_使用JAXB2来实现对象与XML之间的映射
JDK6的新特性之五_轻量级HttpServer
JDK6的新特性之八_嵌入式数据库Derby
JDK6的新特性之六_插入式注解处理API
JDK6的新特性之十_Web服务元数据
JDK6的新特性之十一_更简单强大的JAX-WS
JDK6的新特性之十三_JTable的排序和过滤
JDK6的新特性之十二_脚本语言支持
JDK6的新特性之四_使用Compiler API

JDK6的新特性之一_Desktop类和SystemTray类

JDK6.0发布有段时间了，新的JDK也有不少新的特性，我去网上搜集了一下，列在下面和大家一起学习．
１．Desktop和SystemTray. 在JDK6中 ,AWT新增加了两个类:Desktop和SystemTray,前者可以用来打开系统默认浏览器浏览指定的URL,打开系统默认邮件客户端给指定的邮箱发邮件,用默认应用程序打开或编辑文件(比如,用记事本打开以txt为后缀名的文件),用系统默认的打印机打印文档;后者可以用来在系统托盘区创建一个托盘程序。

我随便找了几张图，在Tray里面都是空的，没有图,可能是图太大，有xdjm知道希望告诉我．

importjava.awt.AWTException;
importjava.awt.Desktop;
importjava.awt.Image;
importjava.awt.MenuItem;
importjava.awt.PopupMenu;
importjava.awt.SystemTray;
importjava.awt.Toolkit;
importjava.awt.TrayIcon;
importjava.awt.event.ActionEvent;
importjava.awt.event.ActionListener;
importjava.io.File;
importjava.io.IOException;
importjava.net.URI;
importjava.net.URISyntaxException;

publicclassDesktopTrayTest{
privatestaticDesktopdesktop;
privatestaticSystemTrayst;
privatestaticPopupMenupm;

publicstaticvoidmain(String[]args){
if(Desktop.isDesktopSupported()){
desktop=Desktop.getDesktop();
}
if(SystemTray.isSupported()){
st=SystemTray.getSystemTray();
Imageimage=Toolkit.getDefaultToolkit().createImage("http://www.51ppt.com.cn/Article/Uploadphotos/200604/20064147333288.png");
createPopupMenu();
TrayIconti=newTrayIcon(image,"Demo",pm);
try{
st.add(ti);
}catch(AWTExceptionawte){
awte.printStackTrace();
}
}
}
publicstaticvoidsendMail(Stringmail){
if(desktop!=null&&
desktop.isSupported(Desktop.Action.MAIL)){
try{
desktop.mail(newURI(mail));
}catch(IOExceptione){
e.printStackTrace();
}catch(URISyntaxExceptione){
e.printStackTrace();
}
}
}
publicstaticvoidopenBrowser(Stringurl){
if(desktop!=null&&
desktop.isSupported(Desktop.Action.BROWSE)){
try{
desktop.browse(newURI(url));
}catch(IOExceptione){
e.printStackTrace();
}catch(URISyntaxExceptione){
e.printStackTrace();
}
}
}
publicstaticvoidedit(){
if(desktop!=null&&
desktop.isSupported(Desktop.Action.EDIT)){
Filefile=newFile("test.txt");
try{
if(file.exists()==false){
file.create();
}
desktop.edit(file);
}catch(IOExceptionioe){
ioe.printStackTrace();
}
}
}
publicstaticvoidcreatePopupMenu(){
pm=newPopupMenu();
MenuItemob=newMenuItem("Openurl");
ob.addActionListener(newActionListener(){
publicvoidactionPerformed(ActionEventae){
openBrowser("http://blog.csdn.net/xumingming64398966");
}
});
MenuItemsm=newMenuItem("SendMail");
sm.addActionListener(newActionListener(){
publicvoidactionPerformed(ActionEventae){
sendMail("[email protected]");
}
});
MenuItemed=newMenuItem("Edit");
ed.addActionListener(newActionListener(){
publicvoidactionPerformed(ActionEventae){
edit();
}
});
MenuItemex=newMenuItem("Exit");
ex.addActionListener(newActionListener(){
publicvoidactionPerformed(ActionEventae){
System.exit(0);
}
});
pm.add(ob);
pm.add(sm);
pm.add(ed);
pm.addSeparator();
pm.add(ex);
}
}

２．Console. JDK6中提供了java.io.Console类专用来访问基于字符的控制台设备. 你的程序如果要与Windows下的cmd或者Linux下的Terminal交互,就可以用Console类代劳. 但我们不总是能得到可用的Console, 一个JVM是否有可用的Console依赖于底层平台和JVM如何被调用. 如果JVM是在交互式命令行(比如Windows的cmd)中启动的,并且输入输出没有重定向到另外的地方,那么就可以得到一个可用的Console实例. 下面代码演示了Console类的用法:

 

importjava.io.Console;

publicclassConsoleTest{
publicstaticvoidmain(String[]args){
Consoleconsole=System.console();
if(console!=null){
Stringuser=newString(console.readLine("EnterUser:",newObject[0]));
Stringpwd=newString(console.readPassword("EnterPassword:",newObject[0]));
console.printf("Usernameis:%s",newObject[]{user});
console.printf("Passwordis:%s",newObject[]{pwd});
}else{
System.out.println("NoConsole!");
}
}
}

 

你如果是在一个IDE中如eclipse, netbeans中运行你将得到：
No Console!
因为只有在命令行中才能得到Console对象。

 

３．Compiler API. 现在我们可以用JDK6 的Compiler API(JSR 199)去动态编译Java源文件，Compiler API结合反射功能就可以实现动态的产生Java代码并编译执行这些代码，有点动态语言的特征。这个特性对于某些需要用到动态编译的应用程序相当有用，比如JSP Web Server，当我们手动修改JSP后，是不希望需要重启Web Server才可以看到效果的，这时候我们就可以用Compiler API来实现动态编译JSP文件，当然，现在的JSP Web Server也是支持JSP热部署的，现在的JSP Web Server通过在运行期间通过Runtime.exec或ProcessBuilder来调用javac来编译代码，这种方式需要我们产生另一个进程去做编译工作，不够优雅而且容易使代码依赖与特定的操作系统；Compiler API通过一套易用的标准的API提供了更加丰富的方式去做动态编译,而且是跨平台的。 下面代码演示了Compiler API的使用：

 

importjava.io.BufferedWriter;
importjava.io.FileWriter;
importjava.io.IOException;
importjava.util.Iterator;

importjavax.tools.JavaCompiler;
importjavax.tools.JavaFileObject;
importjavax.tools.StandardJavaFileManager;
importjavax.tools.ToolProvider;

publicclassCompilerAPITest{
privatefinalstaticStringsrcFileName="Test.java";
privatefinalstaticStringclassFileName="Test.class";
privatefinalstaticStringclassName="Test";

publicstaticvoidmain(String[]args){
JavaCompilercompiler=ToolProvider.getSystemJavaCompiler();
if(compiler==null){
System.err.println("Compilerisnull!");
return;
}
StandardJavaFileManagerfileManager=compiler.getStandardFileManager(null,null,null);
generateJavaClass();

Iterable<?extendsJavaFileObject>sourceFiles=fileManager.getJavaFileObjects(newString[]{srcFileName});
compiler.getTask(null,fileManager,null,null,null,sourceFiles).call();
try{
fileManager.close();
Class.forName(className).newInstance();
}catch(IOExceptione){
e.printStackTrace();
}catch(InstantiationExceptione){
e.printStackTrace();
}catch(IllegalAccessExceptione){
e.printStackTrace();
}catch(ClassNotFoundExceptione){
e.printStackTrace();
}
}

publicstaticvoidgenerateJavaClass(){
try{
FileWriterrw=newFileWriter(srcFileName);
BufferedWriterbw=newBufferedWriter(rw);
bw.write("publicclass"+className+"{");
bw.newLine();

bw.write("public"+className+"(){");
bw.newLine();
bw.write("System.out.println('youareintheconstructorofClassTest');");
bw.write("}");
bw.newLine();

bw.write("}");
bw.flush();
bw.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
}

 

JDK1.6.0新特性详解与代码示例

 

JDK6.0发布有段时间了，新的JDK也有不少新的特性，我去网上搜集了一下，列在下面和大家一起学习．
１．Desktop和SystemTray. 在JDK6中 ,AWT新增加了两个类:Desktop和SystemTray,前者可以用来打开系统默认浏览器浏览指定的URL,打开系统默认邮件客户端给指定的邮箱发邮件,用默认应用程序打开或编辑文件(比如,用记事本打开以txt为后缀名的文件),用系统默认的打印机打印文档;后者可以用来在系统托盘区创建一个托盘程序。

我随便找了几张图，在Tray里面都是空的，没有图,可能是图太大，有xdjm知道希望告诉我．

import java.awt.AWTException;
import java.awt.Desktop;
import java.awt.Image;
import java.awt.MenuItem;
import java.awt.PopupMenu;
import java.awt.SystemTray;
import java.awt.Toolkit;
import java.awt.TrayIcon;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;

public class DesktopTrayTest {
private static Desktop desktop;
private static SystemTray st;
private static PopupMenu pm;

public static void main( String[] args ) {
if( Desktop.isDesktopSupported() ) {
desktop = Desktop.getDesktop();
}
if( SystemTray.isSupported() ) {
st = SystemTray.getSystemTray();
Image image = Toolkit.getDefaultToolkit().createImage( "http://www.51ppt.com.cn/Article/Uploadphotos/200604/20064147333288.png" );
createPopupMenu();
TrayIcon ti = new TrayIcon( image, "Demo", pm );
try{
st.add( ti );
} catch( AWTException awte ) {
awte.printStackTrace();
}
}
}
public static void sendMail( String mail ) {
if( desktop != null &&
desktop.isSupported( Desktop.Action.MAIL ) ) {
try {
desktop.mail( new URI( mail ) );
} catch (IOException e) {
e.printStackTrace();
} catch (URISyntaxException e) {
e.printStackTrace();
}
}
}
public static void openBrowser( String url ) {
if( desktop != null &&
desktop.isSupported( Desktop.Action.BROWSE )) {
try {
desktop.browse( new URI( url ) );
} catch (IOException e) {
e.printStackTrace();
} catch (URISyntaxException e) {
e.printStackTrace();
}
}
}
public static void edit() {
if( desktop != null &&
desktop.isSupported( Desktop.Action.EDIT ) ) {
File file = new File( "test.txt" );
try {
if( file.exists() == false ) {
file.create();
}
desktop.edit( file );
} catch( IOException ioe ) {
ioe.printStackTrace();
}
}
}
public static void createPopupMenu() {
pm = new PopupMenu();
MenuItem ob = new MenuItem( "Open url" );
ob.addActionListener( new ActionListener() {
public void actionPerformed( ActionEvent ae ) {
openBrowser( "http://blog.csdn.net/xumingming64398966" );
}
});
MenuItem sm = new MenuItem( "Send Mail" );
sm.addActionListener( new ActionListener() {
public void actionPerformed( ActionEvent ae ) {
sendMail( "[email protected]" );
}
});
MenuItem ed = new MenuItem( "Edit" );
ed.addActionListener( new ActionListener() {
public void actionPerformed( ActionEvent ae ) {
edit();
}
});
MenuItem ex = new MenuItem( "Exit" );
ex.addActionListener( new ActionListener() {
public void actionPerformed( ActionEvent ae ) {
System.exit( 0 );
}
});
pm.add( ob );
pm.add( sm );
pm.add( ed );
pm.addSeparator();
pm.add( ex );
}
}

 

２．Console. JDK6中提供了java.io.Console类专用来访问基于字符的控制台设备. 你的程序如果要与Windows下的cmd或者Linux下的Terminal交互,就可以用Console类代劳. 但我们不总是能得到可用的Console, 一个JVM是否有可用的Console依赖于底层平台和JVM如何被调用. 如果JVM是在交互式命令行(比如Windows的cmd)中启动的,并且输入输出没有重定向到另外的地方,那么就可以得到一个可用的Console实例. 下面代码演示了Console类的用法:

import java.io.Console;

public class ConsoleTest {
public static void main( String[] args ) {
Console console = System.console();
if( console != null ) {
String user = new String( console.readLine( "Enter User:", new Object[ 0 ] ) );
String pwd = new String( console.readPassword( "Enter Password:", new Object[ 0 ] ));
console.printf( "User name is:%s", new Object[]{user} );
console.printf( "Password is:%s", new Object[]{pwd} );
} else {
System.out.println( "No Console!" );
}
}
}

你如果是在一个IDE中如eclipse, netbeans中运行你将得到：
No Console!
因为只有在命令行中才能得到Console对象。

３．Compiler API. 现在我们可以用JDK6 的Compiler API(JSR 199)去动态编译Java源文件，Compiler API结合反射功能就可以实现动态的产生Java代码并编译执行这些代码，有点动态语言的特征。这个特性对于某些需要用到动态编译的应用程序相当有用，比如JSP Web Server，当我们手动修改JSP后，是不希望需要重启Web Server才可以看到效果的，这时候我们就可以用Compiler API来实现动态编译JSP文件，当然，现在的JSP Web Server也是支持JSP热部署的，现在的JSP Web Server通过在运行期间通过Runtime.exec或ProcessBuilder来调用javac来编译代码，这种方式需要我们产生另一个进程去做编译工作，不够优雅而且容易使代码依赖与特定的操作系统；Compiler API通过一套易用的标准的API提供了更加丰富的方式去做动态编译,而且是跨平台的。 下面代码演示了Compiler API的使用：

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Iterator;

import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;

public class CompilerAPITest {
private final static String srcFileName = "Test.java";
private final static String classFileName = "Test.class";
private final static String className = "Test";

public static void main( String[] args ) {
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
if( compiler == null ) {
System.err.println( "Compiler is null!" );
return;
}
StandardJavaFileManager fileManager = compiler.getStandardFileManager( null, null, null );
generateJavaClass();

Iterable < ? extends JavaFileObject> sourceFiles = fileManager.getJavaFileObjects( new String[]{ srcFileName } );
compiler.getTask( null, fileManager, null, null, null, sourceFiles ).call();
try {
fileManager.close();
Class.forName( className ).newInstance();
} catch (IOException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}

public static void generateJavaClass() {
try {
FileWriter rw = new FileWriter( srcFileName );
BufferedWriter bw = new BufferedWriter( rw );
bw.write( "public class " + className + " {" );
bw.newLine();

bw.write( "public " + className + "() {");
bw.newLine();
bw.write( "System.out.println( 'you are in the constructor of Class Test' );" );
bw.write( "}" );
bw.newLine();

bw.write( "}" );
bw.flush();
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

我在运行这个例子的时候发现ToolProvider.getSystemJavaCompiler得到的是NULL,后来上网一查，原来是一个Bug!链接如下：
http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6477844

Closed, not reproducible
那为什么我一直在reproduce阿？

4.Http Server API. JDK6提供了一个简单的Http Server API,据此我们可以构建自己的嵌入式Http Server,它支持Http和Https协议,提供了HTTP1.1的部分实现，没有被实现的那部分可以通过扩展已有的Http Server API来实现,程序员必须自己实现HttpHandler接口,HttpServer会调用HttpHandler实现类的回调方法来处理客户端请求,在这里,我们把一个Http请求和它的响应称为一个交换,包装成HttpExchange类,HttpServer负责将HttpExchange传给 HttpHandler实现类的回调方法.下面代码演示了怎样创建自己的Http Server .

importjava.io.IOException;
importjava.io.InputStream;
importjava.io.OutputStream;
importjava.net.InetSocketAddress;

importcom.sun.net.httpserver.HttpExchange;
importcom.sun.net.httpserver.HttpHandler;
importcom.sun.net.httpserver.HttpServer;

publicclassHttpServerAPITest{
privatestaticintcount=0;
publicstaticvoidmain(String[]args){
try{
HttpServerhs=HttpServer.create(newInetSocketAddress(8888),0);
hs.createContext("/",newMyHandler());
hs.createContext("/java",newMyHandler());
hs.setExecutor(null);
hs.start();
System.out.println("---begin---");
System.out.println("Listeningon"+hs.getAddress());
}catch(IOExceptionioe){
ioe.printStackTrace();
}
}
staticclassMyHandlerimplementsHttpHandler{
publicvoidhandle(HttpExchangehe)throwsIOException{
System.out.println("Request"+count++);
System.out.println(he.getHttpContext().getPath());

InputStreamis=he.getRequestBody();
Stringresponse="<fontcolor='blue'>HappySpringFesterval</font>";
he.sendResponseHeaders(200,response.length());
OutputStreamos=he.getResponseBody();
os.write(response.getBytes());
os.close();
}
}
}

 

5.对脚本语言的支持如: ruby, groovy, javascript.

importjava.io.FileReader;

importjavax.script.Invocable;
importjavax.script.ScriptEngine;
importjavax.script.ScriptEngineManager;

publicclassScriptTest{
publicstaticvoidmain(String[]args){
ScriptEngineManagermanager=newScriptEngineManager();
ScriptEngineengine=manager.getEngineByName("ECMAScript");
try{
engine.eval(newFileReader("C:/test.js"));
InvocableinvocableEngine=(Invocable)engine;
Objectret=invocableEngine.invokeFunction("test",null);
System.out.println("Theresultis:"+(Double)ret);
}catch(Exceptione){
e.printStackTrace();
}
}
}

test.js如下:

functiontest(){
returnMath.round(11.2);
}

6.插入式注解处理API(Pluggable Annotation Processing API)，插入式注解处理API(JSR 269)提供一套标准API来处理Annotations.JSR 269用Annotation Processor在编译期间而不是运行期间处理Annotation, Annotation Processor相当于编译器的一个插件,所以称为插入式注解处理.如果Annotation Processor处理Annotation时(执行process方法)产生了新的Java代码,编译器会再调用一次Annotation Processor,如果第二次处理还有新代码产生,就会接着调用Annotation Processor,直到没有新代码产生为止.每执行一次process()方法被称为一个"round",这样整个Annotation processing过程可以看作是一个round的序列.
举个例子：们想建立一套基于Annotation的单元测试框架(如TestNG),在测试类里面用Annotation来标识测试期间需要执行的测试方法,如下所示:

@TestMethod
publicvoidtestCheckName(){
//dosomethinghere
}

 

这时我们就可以用JSR 269提供的API来处理测试类,根据Annotation提取出需要执行的测试方法.

再举个例子: 下面我用代码演示如何来用JSR 269提供的API来处理Annotations和读取Java源文件的元数据(metadata)

importjava.util.List;
importjava.util.Map;
importjava.util.Set;

importjavax.annotation.processing.AbstractProcessor;
importjavax.annotation.processing.RoundEnvironment;
importjavax.annotation.processing.SupportedAnnotationTypes;
importjavax.annotation.processing.SupportedSourceVersion;
importjavax.lang.model.SourceVersion;
importjavax.lang.model.element.AnnotationMirror;
importjavax.lang.model.element.AnnotationValue;
importjavax.lang.model.element.Element;
importjavax.lang.model.element.ExecutableElement;
importjavax.lang.model.element.TypeElement;
importjavax.lang.model.util.ElementFilter;
importjavax.tools.Diagnostic.Kind;

@SupportedAnnotationTypes("ToBeTested")
@SupportedSourceVersion(SourceVersion.RELEASE_6)
publicclassMyAnnotationProcessorextendsAbstractProcessor{
privatevoidnote(Stringmsg){
processingEnv.getMessager().printMessage(Kind.NOTE,msg);
}
publicbooleanprocess(Set<?extendsTypeElement>annotations,RoundEnvironmentroundEnv){
for(TypeElementte:annotations){
note("annotation:"+te.toString());
}
Set<?extendsElement>elements=roundEnv.getRootElements();
for(Elemente:elements){
List<?extendsElement>enclosedElems=e.getEnclosedElements();
List<?extendsExecutableElement>ees=ElementFilter.methodsIn(enclosedElems);
for(ExecutableElementee:ees){
note("ExecutableElementName:"+ee.getSimpleName());
List<?extendsAnnotationMirror>as=ee.getAnnotationMirrors();
note("as:"+as);
for(AnnotationMirroram:as){
Map<?extendsExecutableElement,?extendsAnnotationValue>map=am.getElementValues();
Set<?extendsExecutableElement>ks=map.keySet();
for(ExecutableElementk:ks){
AnnotationValueav=map.get(k);
note("----"+ee.getSimpleName()+"."+k.getSimpleName()+"="+av.getValue());
}
}
}
}
returnfalse;
}
}




publicclassTesting{
@ToBeTested(group="A")
publicvoidm1(){
}
@ToBeTested(group="B",owner="QQ")
publicvoidm2(){
}
}



importjava.lang.annotation.ElementType;
importjava.lang.annotation.Retention;
importjava.lang.annotation.RetentionPolicy;
importjava.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public@interfaceToBeTested{
Stringowner()default"Chinajash";
Stringgroup();
}

7.StAX. StAX是The Streaming API for XML的缩写，是继DOM(Document Object Model)和SAX(Simple API for XML)之后的又一种处理xml的api,一种利用拉模式解析(pull-parsing)XML文档的API.StAX通过提供一种基于事件迭代器(Iterator)的API让程序员去控制xml文档解析过程,程序遍历这个事件迭代器去处理每一个解析事件，解析事件可以看做是程序拉出来的，也就是程序促使解析器产生一个解析事件然后处理该事件，之后又促使解析器产生下一个解析事件，如此循环直到碰到文档结束符；SAX也是基于事件处理xml文档，但却是用推模式解析，解析器解析完整个xml文档后，才产生解析事件，然后推给程序去处理这些事件；DOM采用的方式是将整个xml文档映射到一颗内存树，这样就可以很容易地得到父节点和子结点以及兄弟节点的数据，但如果文档很大，将会严重影响性能。

下面是个例子：

importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;

importjavax.xml.namespace.QName;
importjavax.xml.stream.XMLEventReader;
importjavax.xml.stream.XMLInputFactory;
importjavax.xml.stream.XMLOutputFactory;
importjavax.xml.stream.XMLStreamException;
importjavax.xml.stream.XMLStreamWriter;
importjavax.xml.stream.events.StartElement;
importjavax.xml.stream.events.XMLEvent;

publicclassStaxTest{
publicstaticvoidmain(String[]arg)throwsXMLStreamException,FileNotFoundException{
readXMLByStAX();
writeXMLByStAX();
}
publicstaticvoidreadXMLByStAX()throwsXMLStreamException,FileNotFoundException{
XMLInputFactoryfactory=XMLInputFactory.newInstance();
XMLEventReaderreader=factory.createXMLEventReader(StaxTest.class.getResourceAsStream("test.xml"));
XMLEventevent;
StringBufferparsingResult=newStringBuffer();
while(reader.hasNext()){
event=reader.nextEvent();
if(event.isStartElement()){
StartElementse=event.asStartElement();
parsingResult.append("<");
parsingResult.append(se.getName());
if(se.getName().getLocalPart().equals("catalog")){
parsingResult.append("id="");
parsingResult.append(se.getAttributeByName(newQName("id")).getValue());
parsingResult.append(""");
}
parsingResult.append(">");
}elseif(event.isCharacters()){
parsingResult.append(event.asCharacters().getData());
}elseif(event.isEndElement()){
parsingResult.append("</");
parsingResult.append(event.asEndElement().getName());
parsingResult.append(">");
}
}
System.out.println(parsingResult);
}

publicstaticvoidwriteXMLByStAX()throwsXMLStreamException,FileNotFoundException{
XMLOutputFactoryfactory=XMLOutputFactory.newInstance();
XMLStreamWriterwriter=factory.createXMLStreamWriter(newFileOutputStream("output.xml"));
writer.writeStartDocument();
writer.writeCharacters("");
writer.writeComment("testingcomment");
writer.writeCharacters("");
writer.writeStartElement("catalogs");
writer.writeNamespace("myNS","http://blog.csdn.net/Chinajash");
writer.writeAttribute("owner","sina");
writer.writeCharacters("");
writer.writeStartElement("http://blog.csdn.net/Chinajash","catalog");
writer.writeAttribute("id","007");
writer.writeCharacters("Apparel");
//写入catalog元素的结束标签
writer.writeEndElement();
//写入catalogs元素的结束标签
writer.writeEndElement();
//结束XML文档
writer.writeEndDocument();
writer.close();

}
}

test.xml:



<?xmlversion="1.0"encoding="UTF-8"?>
<catalogs>
<catalogid="001">Book</catalog>
<catalogid="002">Video</catalog>
</catalogs>

 

8. Web Service. 由于Web服务日趋流行，利用Web服务的功能性的API特征正从最新的Java EE版本中向Java SE 6平台迁移。换言之，针对Web服务不需另外加入额外的工具，在Java EE和Java SE平台拥有相同的API。野马将大把不同的Web服务相关的API加到标准的工具柜中：以JSR 181针对Java 平台的Web服务元数据，通过JSR 224的基于XML 的Web服务Java API（JAX-WS）；针对Java的带有附件的SOAP API（SAAJ）作为JSR 67 。与三个Web服务API相关的包新增到Java SE 6.0里：JAX－WS API 放置到javax.xml.ws包； SAAJ类在javax.xml.soap 包； Web服务的元数据类放置在javax.jws包里。 下面是一个简单的例子，　下面的代码是要作为web service发布的类。

packagehello;
importjavax.jws.WebService;
importjavax.xml.ws.Endpoint;

@WebService
publicclassCircleFunctions{
publicdoublegetArea(intradius){
returnMath.PI*radius*radius;
}
publicdoublegetCircumference(intradius){
returnMath.PI*radius*2;
}

publicstaticvoidmain(String[]args){
Endpoint.publish("http://localhost:8888/WebServiceExample/circlefunctions",newCircleFunctions());
}
}

 

处理的方法如下：
javac -d ./ CircleFunctions.java
wsgen hello.CircleFunctions
java hello.CircleFunctions
然后在浏览器中输入如下url,你将得到一个xml页面：
http: //localhost:8888/WebServiceExample/circlefunctions?WSDL

参考网页：
1.Desktop和SystemTray. http://dev.yesky.com/411/3019911.shtml
2.Console. http://dev.yesky.com/133/3032133.shtml
3.Compiler API. http://developer.51cto.com/art/200701/37359.htm
4.HttpServer API. http://www.testage.net/QA/Dev/200701/1396.htm
5. 对脚本语言的支持http://blog.edwardro.com/read.php?167
6. 插入式注解处理API. http://ourconan.com.cn/article.php?itemid-2113-type-blog.html
7.StAX. http://ourconan.com.cn/article.php?itemid-2111-type-blog.html
8.Web Service. http://www.360doc.com/showWeb/0/0/298124.aspx
9.JDK1.5的Annotation
http://lzqdiy.bokee.com/viewdiary.14724866.html