很楠不爱3

这个屌丝很懒，什么也没留下！

热门标签

java 1.6特性_JDK1.6.0新特性详解与代码示例

作者：很楠不爱3 | 2024-05-12 05:13:16

踩

jdk1.6

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...{

privatestaticDesktop desktop;

privatestaticSystemTray st;

privatestaticPopupMenu pm;

publicstaticvoidmain( 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=newTrayIcon( image,"Demo", pm );

try...{

st.add( ti );

}catch( AWTException awte )...{

awte.printStackTrace();

} } }

publicstaticvoidsendMail( String mail )...{

if( desktop!=null&&

desktop.isSupported( Desktop.Action.MAIL ) )...{

try...{

desktop.mail(newURI( mail ) );

}catch(IOException e)...{

e.printStackTrace();

}catch(URISyntaxException e)...{

e.printStackTrace();

} } }

publicstaticvoidopenBrowser( String url )...{

if( desktop!=null&&

desktop.isSupported( Desktop.Action.BROWSE ))...{

try...{

desktop.browse(newURI( url ) );

}catch(IOException e)...{

e.printStackTrace();

}catch(URISyntaxException e)...{

e.printStackTrace();

} } }

publicstaticvoidedit()...{

if( desktop!=null&&

desktop.isSupported( Desktop.Action.EDIT ) )...{

File file=newFile("test.txt");

try...{

if( file.exists()==false)...{

file.createNewFile();

} desktop.edit( file );

}catch( IOException ioe )...{

ioe.printStackTrace();

} } }

publicstaticvoidcreatePopupMenu()...{

pm=newPopupMenu();

MenuItem ob=newMenuItem("Open url");

ob.addActionListener(newActionListener()...{

publicvoidactionPerformed( ActionEvent ae )...{

openBrowser("http://blog.csdn.net/xumingming64398966");

} });

MenuItem sm=newMenuItem("Send Mail");

sm.addActionListener(newActionListener()...{

publicvoidactionPerformed( ActionEvent ae )...{

sendMail("64398966@qq.com");

} });

MenuItem ed=newMenuItem("Edit");

ed.addActionListener(newActionListener()...{

publicvoidactionPerformed( ActionEvent ae )...{

edit();

} });

MenuItem ex=newMenuItem("Exit");

ex.addActionListener(newActionListener()...{

publicvoidactionPerformed( 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类的用法:

importjava.io.Console;

publicclassConsoleTest...{

publicstaticvoidmain( String[] args )...{

Console console=System.console();

if( console!=null)...{

String user=newString( console.readLine("Enter User:",newObject[0] ) );

String pwd=newString( console.readPassword("Enter Password:",newObject[0] ));

console.printf("User name is:%s",newObject[]...{user});

console.printf("Password is:%s",newObject[]...{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的使用：

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...{

privatefinalstaticString srcFileName="Test.java";

privatefinalstaticString classFileName="Test.class";

privatefinalstaticString className="Test";

publicstaticvoidmain( 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<?extendsJavaFileObject>sourceFiles=fileManager.getJavaFileObjects(newString[]...{ 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();

} }

publicstaticvoidgenerateJavaClass()...{

try...{

FileWriter rw=newFileWriter( srcFileName );

BufferedWriter bw=newBufferedWriter( 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...{

HttpServer hs=HttpServer.create(newInetSocketAddress(8888),0);

hs.createContext("/",newMyHandler() );

hs.createContext("/java",newMyHandler() );

hs.setExecutor(null);

hs.start();

System.out.println("---begin---");

System.out.println("Listening on"+hs.getAddress() );

}catch( IOException ioe )...{

ioe.printStackTrace();

} }

staticclassMyHandlerimplementsHttpHandler...{

publicvoidhandle( HttpExchange he )throwsIOException...{

System.out.println("Request"+count++);

System.out.println( he.getHttpContext().getPath() );

InputStream is=he.getRequestBody();

String response="Happy Spring Festerval";

he.sendResponseHeaders(200, response.length() );

OutputStream os=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 )...{

ScriptEngineManager manager=newScriptEngineManager();

ScriptEngine engine=manager.getEngineByName("ECMAScript");

try...{

engine.eval(newFileReader("C:\test.js") );

Invocable invocableEngine=(Invocable)engine;

Object ret=invocableEngine.invokeFunction("test",null);

System.out.println("The result is :"+(Double)ret );

}catch( Exception e )...{

e.printStackTrace();

} }}

test.js如下:

functiontest()...{

returnMath.round(11.2);

}

插入式注解处理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()...{

//do something here}

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

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

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.annotation.processing.AbstractProcessor;

import javax.annotation.processing.RoundEnvironment;

import javax.annotation.processing.SupportedAnnotationTypes;

import javax.annotation.processing.SupportedSourceVersion;

import javax.lang.model.SourceVersion;

import javax.lang.model.element.AnnotationMirror;

import javax.lang.model.element.AnnotationValue;

import javax.lang.model.element.Element;

import javax.lang.model.element.ExecutableElement;

import javax.lang.model.element.TypeElement;

import javax.lang.model.util.ElementFilter;

import javax.tools.Diagnostic.Kind;

@SupportedAnnotationTypes("ToBeTested")

@SupportedSourceVersion( SourceVersion.RELEASE_6 )

publicclassMyAnnotationProcessor extends AbstractProcessor...{

privatevoidnote( String msg )...{

processingEnv.getMessager().printMessage( Kind.NOTE, msg );

}

publicboolean process( Set<?extends TypeElement>annotations, RoundEnvironment roundEnv )...{

for( TypeElement te : annotations )...{

note("annotation:"+te.toString() );

} Set<?extends Element>elements=roundEnv.getRootElements();

for( Element e : elements )...{

List<?extends Element>enclosedElems=e.getEnclosedElements();

List<?extends ExecutableElement>ees=ElementFilter.methodsIn( enclosedElems );

for( ExecutableElement ee : ees )...{

note("Executable Element Name:"+ee.getSimpleName() );

List<?extends AnnotationMirror>as=ee.getAnnotationMirrors();

note("as:"+as);

for( AnnotationMirror am :as)...{

Map<?extends ExecutableElement,?extends AnnotationValue>map=am.getElementValues();

Set<?extends ExecutableElement>ks=map.keySet();

for( ExecutableElement k : ks )...{

AnnotationValue av=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...{

String owner()default"Chinajash";

String group();

}

效果如下：

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...{

XMLInputFactory factory=XMLInputFactory.newInstance();

XMLEventReader reader=factory.createXMLEventReader( StaxTest.class.getResourceAsStream("test.xml") );

XMLEvent event;

StringBuffer parsingResult=newStringBuffer();

while( reader.hasNext() )...{

event=reader.nextEvent();

if( event.isStartElement() )...{

StartElement se=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...{

XMLOutputFactory factory=XMLOutputFactory.newInstance();

XMLStreamWriter writer=factory.createXMLStreamWriter(newFileOutputStream("output.xml") );

writer.writeStartDocument();

writer.writeCharacters("");

writer.writeComment("testing comment");

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:

<?xml version="1.0" encoding="UTF-8"?>BookVideo

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

posted on 2007-07-22 22:44 dyerac in java... 阅读(451) 评论(0) 编辑收藏所属分类: 转载学习区

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/557717