www.2527.com_澳门新葡8455手机版_新京葡娱乐场网址_
做最好的网站

JDK各样版本的新特点jdk一计算机编程,六的新特

2019-05-25 10:27 来源:未知

JDK6新特征目录导航:

jdk1.6新特性:

1.Desktop类和SystemTray类
二.运用JAXB二来促成目的与XML之间的照射
3.StAX
4.使用Compiler API
5.轻量级Http Server API
6.插入式注明管理API(Pluggable Annotation Processing API)
七.用Console开拓调控台程序
8.对脚本语言的援助
9.Common Annotations

对此众多刚接触java语言的初学者的话,要打听一门语言,最佳的措施正是要能从基础的本子进行掌握,进级的长河,以及升高的新特性,那样才具鲁人持竿的学好1门语言。今日先为大家介绍一下JDK一.5版本到JDK壹.7本子的表征。希望能给予帮忙。

  • Desktop类和SystemTray类
  • JAXB贰落成指标与XML之间的映照
  • StAX
  • Compiler API
  • 轻量级 Http Server API
  • 插入式证明管理API(Pluggable Annotation Processing API)
  • 用Console开辟调节台程序
  • 对脚本语言的支撑(如:ruby,groovy,javascript)
  • Common Annotations
1.Desktop类和SystemTray类

AWT新添了八个类:Desktop和SystemTray。
  前者能够用来展开系统默许浏览器浏览钦点的U哈弗L,张开系统私下认可邮件客户端给钦赐的邮箱发邮件,用暗许应用程序打开或编辑文件(比方,用记事本展开以txt为后缀名的文本),用系统私下认可的打字与印刷机打字与印刷文书档案;后者能够用来在系统大麦泡区成立1个刺葫芦程序。

JDK1.5新特性:

  1. 机动装箱与拆箱:
    活动装箱的进度:每当须要壹种档案的次序的靶辰时,这种基本类型就自动地包裹到与它同样档次的包装中。
    自行拆箱的历程:每当须要四个值时,棉被服装箱对象中的值就被机关地领抽出来,没须求再去调用intValue()和doubleValue()方法。
    活动装箱,只需将该值赋给三个档期的顺序包装器引用,java会自动创造几个对象。
    电动拆箱,只需将该目的值赋给四个基本项目就可以。
    java——类的包装器
    品类包装器有:Double,Float,Long,Integer,Short,Character和Boolean

  2. 枚举
    把会集里的对象成分3个三个提抽出来。枚举类型使代码更具可读性,领悟清晰,易于维护。枚举类型是强类型的,从而确认保证了系统安全性。而以类的静态字段完成的近乎替代模型,不具有枚举的轻巧性和类型安全性。
    轻巧的用法:JavaEnum简单的用法一般用来代表1组常用常量,可用来表示1类同样档期的顺序的常量值。
    复杂用法:Java为枚举类型提供了有的放到的秘技,同事枚举常量还是可以够有谈得来的章程。能够很有益于的遍历枚举对象。

  3. 静态导入
    经过应用 import static,就足以不要钦赐 Constants 类名而向来行使静态成员,包含静态方法。
    import xxxx 和 import static xxxx的分别是前者一般导入的是类公事如import java.util.Scanner;后者一般是导入静态的措施,import static java.lang.System.out。

  4. 可变参数(Varargs)
    可变参数的简便语法格式为:
    methodName([argumentList], dataType...argumentName);

  5. 内省(Introspector)
    是 Java语言对Bean类属性、事件的一种缺省管理方式。比如类A中有总体性name,那大家能够通过getName,setName来得到其值大概设置新 的值。通过getName/setName来访问name属性,那便是私下认可的规则。Java中提供了1套API用来访问有些属性的getter /setter方法,通过这一个API可以让你无需掌握那些规则(但您最佳仍旧要搞了然),这么些API存放于包java.beans中。
    一 般的做法是通过类Introspector来猎取有个别对象的BeanInfo新闻,然后经过BeanInfo来获取属性的叙说器 (PropertyDescriptor),通过那本性子描述器就能够得到有个别属性对应的getter/setter方法,然后大家就足以通过反射机制来 调用这一个措施。

  6. 泛型(Generic)
    C 通过沙盘技巧可以钦点集结的因素类型,而Java在一.伍此前一贯没有相对应的成效。三个集合能够放任何项指标对象,相应地从会集里面拿对象的时候我们也 不得不对她们开始展览强制得类型转换。猛虎引进了泛型,它同意内定会集里成分的类型,那样您能够得到强类型在编写翻译时刻进行项目检查的补益。

  7. For-Each循环
    For-Each循环得加入简化了聚众的遍历。假使我们要遍历三个聚众对在那之中的要素进行一些管理。

 

贰.运用JAXB贰来贯彻目的与XML之间的映照

JAXB是Java Architecture for XML Binding的缩写,能够将贰个Java对象调换成为XML格式,反之亦然。
  大家把目的与关系数据库之间的投射称为OSportageM,其实也足以把对象与XML之间的映射称为OXM(Object XML Mapping)。原来JAXB是Java EE的一部分,在JDK一.陆中,SUN将其置于了Java SE中,那也是SUN的定点做法。JDK一.陆中自带的这几个JAXB版本是贰.0,比起1.0(JS奔驰M级3一)来,JAXB二(JS昂Cora22二)用JDK伍的新特点Annotation来标记要作绑定的类和性质等,那就大幅简化了付出的专门的学业量。
  实际上,在Java EE 伍.0中,EJB和Web Services也透过Annotation来简化开采工作。别的,JAXB2在底层是用StAX(JS帕杰罗17三)来拍卖XML文书档案。除了JAXB之外,大家还是能经过XMLBeans和Castor等来兑现均等的成效。

JDK 1.6新特性

  1. Desktop类和SystemTray类
    在JDK陆中 ,AWT新增了八个类:Desktop和SystemTray。
    前者能够用来张开系统暗中认可浏览器浏览内定的U奥迪Q三L,展开系统暗中同意邮件客户端给钦点的邮箱发邮件,用暗中认可应用程序打开或编辑文件(比如,用记事本张开以txt为后缀名的文本),用系统暗许的打字与印刷机打字与印刷文书档案;后者能够用来在系统三月泡区创建1个绒毛树莓程序.

  2. 运用JAXB二来完毕指标与XML之间的映照
    JAXB是Java Architecture for XML Binding的缩写,能够将多少个Java对象转换成为XML格式,反之亦然。
    作者们把指标与关全面据库之间的投射称为OOdysseyM, 其实也足以把对象与XML之间的映射称为OXM(Object XML Mapping). 原来JAXB是Java EE的1局地,在JDK六中,SUN将其置于了Java SE中,那也是SUN的原则性做法。JDK六中自带的那些JAXB版本是2.0, 比起1.0(JS奇骏 3一)来,JAXB二(JSSportage22二)用JDK五的新特点Annotation来标记要作绑定的类和品质等,那就小幅简化了付出的专门的学问量。
    实 际上,在Java EE 伍.0中,EJB和Web Services也经过Annotation来简化开垦工作。此外,JAXB二在尾部是用StAX(JS宝马7系17三)来管理XML文书档案。除了JAXB之外,大家还是能够通过XMLBeans和Castor等来促成均等的作用。

  3. 理解StAX
    StAX(JS奇骏 173)是JDK陆.0中除了DOM和SAX之外的又一种处理XML文书档案的API。
    StAX 的来历 :在JAXP一.三(JS帕杰罗 20陆)有三种管理XML文书档案的点子:DOM(Document Object Model)和SAX(Simple API for XML).
    由 于JDK陆.0中的JAXB二(JS纳瓦拉 22贰)和JAX-WS 二.0(JS大切诺基2二四)都会用到StAX所以Sun决定把StAX参预到JAXP家族个中来,并将JAXP的本子晋级到壹.4(JAXP壹.四是JAXP一.3的掩护版 本). JDK6里面JAXP的版本便是1.四. 。
    StAX是The Streaming API for XML的缩写,1种选用拉形式剖判(pull-parsing)XML文书档案的API.StAX通过提供一种基于事件迭代器(Iterator)的API让 程序员去决定xml文书档案解析进程,程序遍历那些事件迭代器去管理每3个剖判事件,深入分析事件能够当做是程序拉出去的,约等于先后促使深入分析器产生一个拆解分析事件 然后甩卖该事件,之后又促使剖判器发生下几个解析事件,如此循环直到蒙受文书档案截至符;
    SAX也是凭仗事件管理xml文档,但却是用推格局深入分析,解析器深入分析完全体xml文书档案后,才发出深入分析事件,然后推给程序去管理这个事件;DOM 接纳的诀要是将全体xml文书档案映射到1颗内部存款和储蓄器树,那样就足以很轻便地收获父节点和子结点以及兄弟节点的多寡,但若是文书档案极大,将会严重影响属性。

  4. 使用Compiler API
    以后自家 们可以用JDK6 的Compiler API(JSLacrosse19玖)去动态编写翻译Java源文件,Compiler API结合反射功效就能够兑现动态的产生Java代码并编译实施这几个代码,有一些动态语言的特点。
    那 个特征对于某个供给用到动态编写翻译的应用程序非常有用, 譬如JSP Web Server,当大家手动修改JSP后,是不指望须求重启Web Server技巧够看看效果的,那时候大家就可以用Compiler API来促成动态编写翻译JSP文件,当然,今后的JSP Web Server也是扶助JSP热安排的,现在的JSP Web Server通过在运营期间通过Runtime.exec或ProcessBuilder来调用javac来编译代码,这种措施亟待我们发出另2个经过去 做编写翻译专业,远远不足优雅同一时候便于使代码依赖与特定的操作系统;Compiler API通过1套易用的正统的API提供了进一步助长的点子去做动态编译,而且是跨平台的。

  5. 轻量级Http Server API
    JDK陆 提供了3个粗略的Http Server API,据此我们能够创设筑协会调的嵌入式Http Server,它援救Http和Https协议,提供了HTTP一.1的有的完成,未有被达成的那有个别能够由此扩充已有些Http Server API来促成,程序猿必须自身完毕HttpHandler接口,HttpServer会调用HttpHandler完成类的回调方法来管理客户端请求,在 这里,大家把三个Http请求和它的响应称为3个换到,包装成HttpExchange类,HttpServer担任将HttpExchange传给 HttpHandler完结类的回调方法.

  6. 插入式表明管理API(Pluggable Annotation Processing API)
    插入式评释管理API(JSEvoque 26玖)提供1套规范API来拍卖Annotations(JSENVISION17伍)
    实 际上JS酷路泽26玖不但用来管理Annotation,俺觉着更加强有力的功能是它确立了Java 语言本人的3个模子,它把method, package, constructor, type, variable, enum, annotation等Java语言因素映射为Types和Elements(两个有哪些分别?), 从而将Java语言的语义映射成为指标, 大家能够在javax.lang.model包下边可以看到那几个类. 所以大家得以行使JSRubicon26九提供的API来塑造3个功能丰裕的元编制程序(metaprogramming)境况.
    JSSportage 26九用Annotation Processor在编写翻译时期而不是运作时期管理Annotation, Annotation Processor也就是编写翻译器的1个插件,所以称为插入式注明管理.假诺Annotation Processor管理Annotation时(实践process方法)产生了新的Java代码,编写翻译器会再调用三回Annotation Processor,借使第二次拍卖还会有新代码发生,就能跟着调用Annotation Processor,直到未有新代码产生截至.每试行贰回process()方法被誉为3个"round",那样任何Annotation processing进程能够视作是一个round的连串.
    JSRubicon 26⑨根本被规划成为针对Tools只怕容器的API. 举个例证,大家想创建一套基于Annotation的单元测试框架(如TestNG),在测试类里面用Annotation来标志测试时期供给施行的测试方法。

  7. 用Console开拓调控台程序
    JDK陆 中提供了java.io.Console 类专项使用来走访基于字符的垄断台设备. 你的次序壹旦要与Windows下的cmd恐怕Linux下的Terminal交互,就足以用Console类代劳. 但大家不接二连三能博取可用的Console, 二个JVM是不是有可用的Console依赖于底层平台和JVM怎么样被调用. 倘使JVM是在交互式命令行(比如Windows的cmd)中运行的,并且输入输出未有重定向到其它的地点,那么就能够得到1个可用的Console实 例.

  8. 对脚本语言的支撑如: ruby, groovy, javascript.

  9. Common Annotations
    Common annotations原本是Java EE 5.0(JS君越24四)规范的一部分,今后SUN把它的一部分放到了Java SE 陆.0中.
    乘势Annotation元数据成效(JS中华V 175)参加到Java SE 5.0里头,多数Java 技能(举个例子EJB,Web Services)都会用Annotation部分代表XML文件来配置运转参数(或许说是协助评释式编制程序,如EJB的申明式事务), 倘若那一个才干为通用目标都独立定义了友好的Annotations,明显不怎么重复建设, 所以,为其它相关的Java工夫定义1套公共的Annotation是有价值的,能够幸免双重建设的同期,也确定保证Java SE和Java EE 各样本事的一模二样性.
    下边列举出Common Annotations 1.0里边的拾一个Annotations Common Annotations
    Annotation Retention Target Description
    Generated Source ANNOTATION_TYPE, CONSTRUCTOR, FIELD, LOCAL_VA途观IABLE, METHOD, PACKAGE, PARAMETE福特Explorer, TYPE 用于表明生成的源代码
    Resource Runtime TYPE, METHOD, FIELD 用于标明所依赖的能源,容器据此注入外部财富注重,有凭借字段的注入和依照setter方法的流入二种方法
    Resources Runtime TYPE 同期表明多少个外表看重,容器会把具有这一个外部正视注入
    PostConstruct Runtime METHOD 标明当容器注入全数信赖之后运营的章程,用来进展重视注入后的伊始化专门的事业,唯有三个艺术能够标明为PostConstruct
    PreDestroy Runtime METHOD 当对象实例就要被从容器个中删掉此前,要实施的回调方法要标明为PreDestroy RunAs Runtime TYPE 用于标明用什么安全剧中人物来进行被标明类的秘籍,这么些安全剧中人物必须和Container 的Security剧中人物一致的。RolesAllowed Runtime TYPE, METHOD 用于标明允许实施被标记类或方法的景德镇剧中人物,那些安全剧中人物必须和Container 的Security剧中人物1致的
    PermitAll Runtime TYPE, METHOD 允许持有剧中人物实践被标记的类或艺术
    DenyAll Runtime TYPE, METHOD 不一致意别的剧中人物试行被阐明的类或艺术,评释该类或方式不可能在Java EE容器里面运转
    DeclareRoles Runtime TYPE 用来定义能够被应用程序查验的日喀则角色,日常用isUserInRole来验证安全角色
    注意:
    a. RolesAllowed,PermitAll,DenyAll不能同期选用到三个类或形式上
    b. 表明在情势上的RolesAllowed,PermitAll,DenyAll会覆盖标记在类上的RolesAllowed,PermitAll,DenyAll
    c. RunAs,RolesAllowed,PermitAll,DenyAll和DeclareRoles还从未加到Java SE 6.0上来
    d. 管理以上Annotations的办事是由Java EE容器来做, Java SE 陆.0只是包括了上边表格的前多种Annotations的定义类,并从未蕴涵管理那些Annotations的外燃机,这么些专业能够由Pluggable Annotation Processing API(JSMurano 26九)来做

更改的地方最大的正是java GUI分界面包车型地铁展现了,JDK6.0(也正是JDK一.陆)帮助最新的windows vista系统的Windows Aero视窗效果,而JDK1.5不协助!!!
您要在vista意况下编制程序的话最棒装jdk六.0,不然它连接换来windows basic视窗效果.

Desktop类和SystemTray类

JDK陆在java.awt包下新扩张了八个类:Desktop和SystemTray

Desktop类:允许 Java 应用程序运行已在本机桌面上注册的关联应用程序来管理 USportageI 或文件。

计算机编程 1

Desktop类的重中之重措施:

一.browse(U揽胜极光I uri): 使用暗中认可浏览器打开uri财富。

贰.checkActionSupport(Action actionType): 检查是还是不是扶助的Action。

3.open(File file): 运营关联应用程序来开荒文件。

肆.edit(File file): 运维关联编辑器应用程序并张开一个文书编写。

5.print(File file): 使用关联应用程序打字与印刷文件。

陆.mail(): 运行用户暗中同意邮件客户端的邮件组合窗口。

七.mail(UTucsonI mailtoURI): 运转用户暗中认可邮件客户端的邮件组合窗口, 填充由 mailto:ULANDI 内定的消息字段。

身体力行代码:

 1 import java.awt.*;
 2 import java.io.File;
 3 import java.io.IOException;
 4 import java.net.URI;
 5 
 6 public class Test {
 7     public static void main(String[] args) throws IOException {
 8         //先判断当前平台是否支持Desktop类
 9         if (Desktop.isDesktopSupported()) {
10             //获取Desktop实例
11             Desktop desktop = Desktop.getDesktop();
12             //使用默认浏览器打开链接
13             desktop.browse(URI.create("http://www.cnblogs.com/peter1018"));
14             // 打开指定文件/文件夹
15             desktop.open(new File("D:\"));
16 
17             //......
18 
19             //其他方法可以自行演示...
20         }else {
21             System.out.println("当前平台不支持 Desktop类!");
22         }
23 
24     }
25 
26 }

SystemTray类:代表贰个系统四月泡桌面。在微软的Windows上,它被称作“职分栏”状态区域,在Gnome上,它被称作“文告”在KDE上,它被堪当“系统绒毛地仙泡”。该系统沙窝窝由在桌面上运转的兼具应用程序共享。

计算机编程 2

SystemTray类的重中之重格局:

壹.isSupported() : 检查评定类别是还是不是扶助SystemTray类。

2.getSystemTray() : 获得SystemTray实例。

1.add(TrayIcon trayIcon): 在“系统大麦泡”上增加三个“TrayIcon”。TrayIcon对象表示三个复盆子Logo,它能够有一个工具提示(文本),1个图像,二个弹出框菜单,以及一组与之有关的侦听器。欧洲糙莓Logo1旦出现,就能在系统大麦泡中显示。

贰.remove(TrayIcon trayIcon): 删除钦赐的“TrayIcon”。

三.getTrayIcons(): 返回一个由那么些欧洲欧洲糙莓加多到绒毛红绒毛悬钩子上的装有Logo的数组应用程序。

4.getTrayIconSize():  以像素为单位,重临在系统木莓中据为己有的八个木莓图标的深浅。

伍.addPropertyChangeListener(String propertyName,PropertyChangeListener listener): 将 PropertyChangeListener 加多到监听器

陆.removePropertyChangeListener(String propertyName,PropertyChangeListener listener): 将PropertyChangeListener 从监听器移除

七.getPropertyChangeListeners(String propertyName) : 重回全部已涉嫌的监听器数组

身体力行代码:

 

 1 import javax.swing.*;
 2 import java.awt.*;
 3 
 4 public class Test {
 5     public static void main(String[] args) throws AWTException {
 6         //先判断当前平台是否支持SystemTray类
 7         if (SystemTray.isSupported()) {
 8             //获取SystemTray实例
 9             SystemTray systemTray = SystemTray.getSystemTray();
10             //获得托盘显示图标
11             ImageIcon imageIcon=new ImageIcon("D:\icon.jpg");
12             //获得Image对象
13             Image icon=imageIcon.getImage();
14             //任务栏程序托盘图标
15             TrayIcon trayicon = new TrayIcon(icon,"JAVA系统托盘");
16             //关键点,设置托盘图标的自适应属性,这样才能在系统显示托盘处正常显示出需要的图片。
17             trayicon.setImageAutoSize(true);
18             //添加系统托盘
19             systemTray.add(trayicon);
20             //......
21             //其他方法可以自行演示...
22             //移除系统托盘
23             systemTray.remove(trayicon);
24         }else {
25             System.out.println("当前平台不支持 SystemTray类!");
26         }
27 
28     }
29 
30 }

 

呈现结果如下:

计算机编程 3

 

3.StAX

StAX(JSRubicon 17叁)是JDK1.陆.0中除了DOM和SAX之外的又一种管理XML文书档案的API。
  StAX 的来路:在JAXP1.叁(JSCR-V 206)有二种管理XML文书档案的情势:DOM(Document Object Model)和SAX(Simple API for XML)。
  由于JDK一.陆.0中的JAXB二(JS宝马X5 22二)和JAX-WS 二.0(JS卡宴2②四)都会用到StAX所以Sun决定把StAX参预到JAXP家族个中来,并将JAXP的本子晋级到一.4(JAXP一.四是JAXP1.三的掩护版本)。JDK一.六里面JAXP的版本正是一.四。
  StAX是The Streaming API for XML的缩写,一种采纳拉格局分析(pull-parsing)XML文书档案的API.StAX通过提供1种基于事件迭代器(Iterator)的API让技师去决定xml文书档案解析进度,程序遍历那一个事件迭代器去处理每三个剖判事件,深入分析事件能够看作是程序拉出来的,也正是先后促使深入分析器产生一个深入分析事件然后管理该事件,之后又促使分析器爆发下三个分析事件,如此循环直到境遇文书档案甘休符;
  SAX也是依据事件管理xml文书档案,但却是用推情势解析,剖析器深入分析完全部xml文书档案后,才爆发剖判事件,然后推给程序去管理这一个事件;DOM选拔的法子是将全部xml文书档案映射到壹颗内部存款和储蓄器树,那样就足以很轻便地猎取父节点和子结点以及兄弟节点的多少,但借使文书档案相当的大,将会严重影响属性。

JAXB二完毕目的与XML之间的照射

JAXB是Java Architecture for XML Binding的缩写,能够将2个Java对象调换成为XML格式,反之亦然。大家把指标与关周详据库之间的映照称为O途胜M, 其实也能够把对象与XML之间的照耀称为OXM(Object XML Mapping)。原来JAXB是Java EE的一有的,在JDK陆中,SUN将其放置了Java SE中,那也是SUN的定位做法。JDK陆中自带的那个JAXB版本是二.0, 比起壹.0(JSRubicon 3一)来,JAXB二(JS奇骏 22二)用JDK5的新特色Annotation来标志要作绑定的类和性子等,那就大幅简化了费用的专门的学问量。实际上,在Java EE 5.0中,EJB和Web Services也经过Annotation来简化开垦职业。别的,JAXB贰在底部是用StAX(JSOdyssey 17三)来处理XML文书档案。 

重大的讲授和表明

注解 说明

@XmlRootElement

将类或enum类型映射到XML元素,类名或名作为根节点

@XmlAttribute

将JavaBean属性映射到XML属性

@XmlElement

将JavaBean属性映射到源自属性名的XML元素

@XmlAnyAttribute

将JavaBean属性映射到通配符属性的映射

@XmlAnyElement

将JavaBean属性映射到XML infoset或JAXB

@XmlElements

一个用于多XmlElement注解的容器。

@XmlID

将JavaBean属性映射到XML ID

@XmlIDREF

将JavaBean属性映射到XML IDREF

@XmlList

用来将一个属性映射到一个List

@XmlSchema

将包映射到XML名称空间

@XmlTransient

该属性无需映射到XML

 

示范代码:

Address类

 1 import javax.xml.bind.annotation.XmlAttribute;
 2 import javax.xml.bind.annotation.XmlElement;
 3 
 4 public class Address {
 5 
 6     @XmlAttribute
 7     String province;
 8     @XmlElement
 9     String area;
10     @XmlElement
11     String street;
12 
13     public Address() {}
14 
15     public Address(String province, String area, String street) {
16         this.province = province;
17         this.area = area;
18         this.street = street;
19     }
20 
21     @Override
22     public String toString() {
23         return "Address{"  
24                 "province='"   province   '''  
25                 ", area='"   area   '''  
26                 ", street='"   street   '''  
27                 '}';
28     }
29 }

Person类

 1 import javax.xml.bind.annotation.XmlAttribute;
 2 import javax.xml.bind.annotation.XmlElement;
 3 import javax.xml.bind.annotation.XmlRootElement;
 4 
 5 @XmlRootElement
 6 public class Person{
 7 
 8     @XmlAttribute
 9     private String name;
10 
11     @XmlElement
12     private int age;
13 
14     @XmlElement
15     private Address address;
16 
17     public Person() {
18     }
19 
20     public Person(String name, int age, Address address) {
21         this.name = name;
22         this.age = age;
23         this.address = address;
24     }
25 
26     @Override
27     public String toString() {
28         return "Person{"  
29                 "name='"   name   '''  
30                 ", age="   age  
31                 ", address="   address  
32                 '}';
33     }
34 }

测试类:

 1 import javax.xml.bind.JAXBContext;
 2 import javax.xml.bind.JAXBException;
 3 import javax.xml.bind.Marshaller;
 4 import javax.xml.bind.Unmarshaller;
 5 import java.io.FileReader;
 6 import java.io.FileWriter;
 7 import java.io.IOException;
 8 
 9 public class Test {
10     public static void main(String[] args) throws JAXBException, IOException {
11         JAXBContext jaxbContext = JAXBContext.newInstance(Person.class);
12 
13         //根据Person对象转换为person.xml文件
14         Marshaller marshaller = jaxbContext.createMarshaller();
15         Address address = new Address("广东省","深圳市","宝安区");
16         Person person = new Person("niannianjiuwang", 20, address);
17         FileWriter fileWriter = new FileWriter("D:\person.xml");
18         marshaller.marshal(person, fileWriter);
19 
20         //根据person.xml文件转换为对象
21         FileReader fileReader = new FileReader("D:\person.xml");
22         Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
23         Person personNew = (Person) unmarshaller.unmarshal(fileReader);
24         System.out.println(personNew);
25     }
26 }

出口结果:

先看看person.xml文件:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<person name="niannianjiuwang">
    <age>20</age>
    <address province="广东省">
        <area>深圳市</area>
        <street>宝安区</street>
    </address>
</person>

调节台结果:

Person{name='niannianjiuwang', age=20, address=Address{province='广东省', area='深圳市', street='宝安区'}}

 

4.使用Compiler API

最近自身 们能够用JDK壹.6 的Compiler API(JS揽胜极光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提供了特别助长的章程去做动态编写翻译,而且是跨平台的。

StAX

StAX的来历 :

在JAXP1.3(JSR 206)有二种处理XML文书档案的点子:DOM(Document Object Model)和SAX(Simple API for XML).由于JDK6.0中的JAXB2(JSR 222)和JAX-WS 2.0(JSR 224)都会用到StAX所以Sun决定把StAX出席到JAXP家族在那之中来,并将JAXP的本子进级到1.四(JAXP一.四是JAXP一.三的保养版本). JDK陆里面JAXP的本子就是1.四。

StAX简介:

StAX是Streaming API for XML的缩写,它富含在200肆年一月的JSRAV4 173中。StAX是JDK陆.0中富含的新特色。
在推式模型中,直到全数XML文件全体被深入分析,分析器才会发出剖析事件。而拉式剖判由应用程序来支配,也便是说分析事件由应用程序产生。那就表示,你能够舒缓分析、深入分析时跳过有些成分只怕同临时间剖判八个公文。用DOM深入分析式要先将XML文件分析成DOM结构,由此下跌了深入分析功效。使用StAX,解析事件在XML文件深入分析进度中发生。

上边是各样剖析方法之间的可比:

XML Parser API Feature Summary
Feature StAX SAX DOM TrAX
API Type Pull, streaming Pull, streaming In memory tree XSLT Rule
Ease of Use High Medium High Medium
XPath Capability No No Yes Yes
CPU and Memory Efficiency Good Good Varies Varies
Forward Only Yes Yes No No
Read XML Yes Yes Yes Yes
Write XML Yes No Yes Yes
Create, Read, Update, Delete No No Yes No

StAX API一样也在JWSDP(Java Web Services Developer Pack )一.陆中收获贯彻,你能够在包javax.xml.stream 中找到它。XMLStreamReader接口用来分析XML文件。XMLStreamWriter接口用来生成XML文件,XML伊夫ntReader用贰个对象事件迭代器来剖判XML事件。与之相反,XMLStreamReader选用的是游标机制。

示范代码:

 

 1 import javax.xml.stream.*;
 2 import javax.xml.stream.events.XMLEvent;
 3 import java.io.FileInputStream;
 4 import java.io.FileNotFoundException;
 5 import java.io.FileOutputStream;
 6 
 7 public class Test {
 8     public static void main(String[] args) throws FileNotFoundException, XMLStreamException {
 9         writeXMLByStAX();//用XMLStreamWriter写xml文档
10         readXMLByStAX();//用XMLEventReader解析xml文档
11     }
12 
13     /**
14      * 通过StAX读XML
15      */
16     private static void readXMLByStAX() throws XMLStreamException, FileNotFoundException {
17         XMLInputFactory xmlif = XMLInputFactory.newInstance();
18         XMLEventReader xmler = xmlif.createXMLEventReader(new FileInputStream("D:\write.xml"));
19         XMLEvent event;
20         StringBuffer parsingResult = new StringBuffer();
21         while (xmler.hasNext()) {
22             event = xmler.nextEvent();
23             parsingResult.append(event.toString());
24         }
25         System.out.println(parsingResult);
26     }
27 
28     /**
29      * 通过StAX写XML
30      */
31     private static void writeXMLByStAX() throws FileNotFoundException, XMLStreamException {
32         XMLOutputFactory xmlOutputFactory = XMLOutputFactory.newFactory();
33         XMLStreamWriter xmlStreamWriter = xmlOutputFactory.createXMLStreamWriter(new FileOutputStream("D:\write.xml"));
34 
35         // 写入默认的 XML 声明到xml文档
36         xmlStreamWriter.writeStartDocument();
37         // 写入注释到xml文档
38         xmlStreamWriter.writeComment("testing comment");
39         // 写入一个catalogs根元素
40         xmlStreamWriter.writeStartElement("catalogs");
41         xmlStreamWriter.writeNamespace("myUrl", "http://www.cnblogs.com/peter1018");
42         xmlStreamWriter.writeAttribute("name","niannianjiuwang");
43         // 写入子元素catalog
44         xmlStreamWriter.writeStartElement("http://www.cnblogs.com/peter1018", "catalog");
45         xmlStreamWriter.writeAttribute("id","StAX");
46         xmlStreamWriter.writeCharacters("Apparel");
47         // 写入catalog元素的结束标签
48         xmlStreamWriter.writeEndElement();
49         // 写入catalogs元素的结束标签
50         xmlStreamWriter.writeEndElement();
51         // 结束 XML 文档
52         xmlStreamWriter.writeEndDocument();
53         xmlStreamWriter.close();
54     }
55 }

输出结果:

write.xml文件内容:

<?xml version="1.0" ?><!--testing comment--><catalogs xmlns:myUrl="http://www.cnblogs.com/peter1018" name="niannianjiuwang"><myUrl:catalog id="StAX">Apparel</myUrl:catalog></catalogs>

 

调控台打字与印刷结果:

<?xml version="1.0" encoding='UTF-8' standalone='no'?><!--testing comment--><catalogs name='niannianjiuwang' xmlns:myUrl='http://www.cnblogs.com/peter1018'><['http://www.cnblogs.com/peter1018']:myUrl:catalog id='StAX'>Apparel</['http://www.cnblogs.com/peter1018']:myUrl:catalog></catalogs>ENDDOCUMENT

 

5.轻量级Http Server API

JDK一.陆 提供了叁个归纳的Http Server API,据此大家能够营造谐和的嵌入式Http Server,它援助Http和Https协议,提供了HTTP一.1的有的实现,未有被完成的那有些可以因此扩大已部分Http Server API来达成,技师必须团结达成HttpHandler接口,HttpServer会调用HttpHandler完成类的回调方法来管理客户端请求,在那边,大家把3个Http请求和它的响应称为贰个置换,包装成HttpExchange类,HttpServer担任将HttpExchange传给HttpHandler达成类的回调方法。

Compiler API

Java编制程序语言编写翻译器javac读取以Java编制程序语言编写的源文件,并将它们编写翻译为字节码class文件。可能,编写翻译器也得以使用注明找到源文件和类公事并应用comiler API。编写翻译器是三个命令行工具,但也能够利用Java compiler API调用。原话:(官方网站介绍)

咱俩得以用JDK陆 的Compiler API(JSCRUISER 19玖)去动态编写翻译Java源文件,Compiler API结合反射功用就足以兑现动态的产生Java代码并编写翻译实施那一个代码,有一点动态语言的特点。那几个性格对于有些须求用到动态编写翻译的应用程序非常有用, 举个例子JSP Web Server,当大家手动修改JSP后,是不期待需求重启Web Server能力够看来效果的,那时候大家就可以用Compiler API来达成动态编写翻译JSP文件,当然,未来的JSP Web Server也是支撑JSP热陈设的,未来的JSP Web Server通过在运作时期通过Runtime.exec或ProcessBuilder来调用javac来编写翻译代码,这种艺术需求我们发出另3个经过去做编写翻译专门的工作,相当不够优雅同偶尔间便于使代码信赖与特定的操作系统;Compiler API通过1套易用的规范的API提供了进一步助长的秘籍去做动态编写翻译,而且是跨平台的。

六.插入式注明处理API(Pluggable Annotation Processing API)

插入式注脚管理API(JS大切诺基 269)提供壹套标准API来管理Annotations(JS福特Explorer 17伍)
  实际上JS君越26九不唯有用来管理Annotation,作者感到更加强劲的功效是它成立了Java 语言本人的1个模子,它把method,package,constructor,type,variable, enum,annotation等Java语言因素映射为Types和Elements(两个有如何不一致?),从而将Java语言的语义映射成为目的,我们能够在javax.lang.model包上边能够看到那么些类。 所以大家能够使用JS奥迪Q526玖提供的API来构建2个成效丰富的元编制程序(metaprogramming)遇到。
  JSRubicon 26九用Annotation Processor在编写翻译期间而不是运营时期管理Annotation,Annotation Processor也就是编译器的1个插件,所以称为插入式注明管理.倘使Annotation Processor管理Annotation时(实践process方法)产生了新的Java代码,编写翻译器会再调用一回Annotation Processor,如果第二遍拍卖还应该有新代码产生,就能够跟着调用Annotation Processor,直到未有新代码发生截至.每奉行一遍process()方法被堪当八个"round",那样全体Annotation processing进程能够当作是二个round的行列。
  JS翼虎 26玖首要被设计改为针对Tools或许容器的API. 比如,大家想创设一套基于Annotation的单元测试框架(如TestNG),在测试类里面用Annotation来标记测试期间须求实践的测试方法。

API Specification

  • javax.annotation.processing - Annotation processing.
  • javax.lang.model - Language model used in annotation processing and Compiler Tree API
    • javax.lang.model.element - Language elements.
    • javax.lang.model.type - Types.
    • javax.lang.model.util - Language model utilities.
  • javax.tools - Java Compiler API.
  • com.sun.source.* - Compiler Tree API.

 

演示代码:(Tips:运营代码此前务必在D目录下存放TestObject.java文件)

 1 import javax.tools.JavaCompiler;
 2 import javax.tools.JavaFileObject;
 3 import javax.tools.StandardJavaFileManager;
 4 import javax.tools.ToolProvider;
 5 import java.io.IOException;
 6 
 7 public class Test {
 8     public static void main(String[] args) throws IOException {
 9         JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
10         StandardJavaFileManager standardJavaFileManager = compiler.getStandardFileManager(null,null,null);
11         Iterable<? extends JavaFileObject> sourcefiles = standardJavaFileManager.getJavaFileObjects("D:\TestObject.java");
12         compiler.getTask(null, standardJavaFileManager, null, null, null, sourcefiles).call();
13         standardJavaFileManager.close();
14 
15     }
16 }

输出结果:会在D目录下生成TestObject.class文件。

柒.用Console开辟调控台程序

JDK一.6中提供了java.io.Console 类专项使用来走访基于字符的调节台设备。你的先后一旦要与Windows下的cmd大概Linux下的Terminal交互,就足以用Console类代劳。但我们不总是能猎取可用的Console,八个JVM是或不是有可用的Console注重于底层平台和JVM如何被调用。要是JVM是在交互式命令行(举例Windows的cmd)中运行的,并且输入输出未有重定向到别的的地点,那么就能够赢得多少个可用的Console实例。

轻量级 Http Server API 

JDK陆 提供了多少个轻易的Http Server API,据此大家能够营造协调的嵌入式Http Server,它帮助Http和Https协议,提供了HTTP一.壹的部分完毕,没有被实现的这有些可以经过扩大已部分Http Server API来促成,必须和煦达成HttpHandler接口,HttpServer会调用HttpHandler达成类的回调方法来管理客户端请求,大家把贰个Http请求和它的响应称为1个沟通,包装成HttpExchange类,HttpServer肩负将HttpExchange传给 HttpHandler实现类的回调方法。

演示代码:

 1 import com.sun.net.httpserver.HttpExchange;
 2 import com.sun.net.httpserver.HttpHandler;
 3 
 4 import java.io.*;
 5 
 6 public class TestHandler implements HttpHandler {
 7 
 8 
 9     @Override
10     public void handle(HttpExchange httpExchange) throws IOException {
11         System.out.println("==进入Hadnler方法");
12         String responseMsg = "OK";   //响应信息
13         InputStream in = httpExchange.getRequestBody(); //获得输入流
14         BufferedReader reader = new BufferedReader(new InputStreamReader(in));
15         String temp = null;
16         while((temp = reader.readLine()) != null) {
17             System.out.println("client request:" temp);
18         }
19         httpExchange.sendResponseHeaders(200, responseMsg.length()); //设置响应头属性及响应信息的长度
20         OutputStream out = httpExchange.getResponseBody();  //获得输出流
21         out.write(responseMsg.getBytes());
22         out.flush();
23         httpExchange.close();
24     }
25 }

 1 import com.sun.net.httpserver.HttpServer;
 2 import com.sun.net.httpserver.spi.HttpServerProvider;
 3 
 4 import java.io.IOException;
 5 import java.net.InetSocketAddress;
 6 
 7 public class Test {
 8     public static void main(String[] args) throws IOException {
 9         //启动服务,监听来自客户端的请求
10         HttpServerProvider provider = HttpServerProvider.provider();
11         //监听8888端口,能同时接受100个请求
12         HttpServer httpserver =provider.createHttpServer(new InetSocketAddress(8888), 100);
13         //将 /test  请求交给 TestHandler 处理器处理
14         httpserver.createContext("/test", new TestHandler());
15         httpserver.setExecutor(null);
16         httpserver.start();
17         System.out.println("server started");
18     }
19 }

出口结果:

server started
==进入Hadnler方法
==进入Hadnler方法
==进入Hadnler方法

计算机编程 4

 

八.对脚本语言的支撑

如: ruby,groovy,javascript。

插入式申明管理 API(Pluggable Annotation Processing API)

插入式阐明管理API(JSR 269)提供一套规范API来拍卖Annotations(JSR 175)。实际上JS君越26⑨不但用来管理Annotation,它还确立了Java 语言自个儿的一个模型,它把method, package, constructor, type, variable, enum,,annotation等Java语言成分映射为Types和Elements, 从而将Java语言的语义映射成为目的,大家得以在javax.lang.model包下边能够看看这么些类. 所以大家能够运用JS奥德赛26玖提供的API来构建叁个功用丰裕的元编程(metaprogramming)意况。JSSportage269用Annotation Processor在编写翻译时期而不是运转时期管理Annotation, Annotation Processor相当于编写翻译器的2个插件,所以称为插入式阐明管理。假诺Annotation Processor处理Annotation时(实行process方法)产生了新的Java代码,编译器会再调用三次Annotation Processor,倘若第三回拍卖还或者有新代码发生,就能够随之调用Annotation Processor,直到未有新代码爆发停止。每施行三回process()方法被称之为二个"round",那样全体Annotation processing进度能够看做是一个round的类别,JSLAND26玖主要被规划改为针对Tools只怕容器的API。

举例,大家想创建1套基于Annotation的单元测试框架(如TestNG),在测试类里面用Annotation来标志测试时期必要进行的测试方法,如下所示:

@TestMethod
 public void testCheckName(){
       //do something here
 }

那时我们就能够用JS本田UR-V26玖提供的API来管理测试类,依照Annotation提抽取须要奉行的测试方法。

另一个事例是假使大家是因为某种原因需求活动开采八个适合Java EE 五.0的Application Server(当然不提出那样做),我们就不可忽视理Common Annotations(JSR 250),Web Services Metadata(JSR 181)等专门的学问的Annotations,这时能够用JSTiggo26玖提供的API来拍卖这么些Annotations. 在后天的开采工具里面,Eclipse 3.叁承诺将支撑JS奇骏 269

上边小编用代码演示怎样来用JS科雷傲26玖提供的API来拍卖Annotations和读取Java源文件的元数据(metadata)

@SupportedAnnotationTypes("PluggableAPT.ToBeTested")//可以用"*"表示支持所有Annotations
@SupportedSourceVersion(SourceVersion.RELEASE_6)
public class MyAnnotationProcessor extends AbstractProcessor {
    private void note(String msg) {
        processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, msg);
    }
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        //annotations的值是通过@SupportedAnnotationTypes声明的且目标源代码拥有的所有Annotations
        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("--ExecutableElement name is " ee.getSimpleName());
                List<? extends AnnotationMirror> as = ee.getAnnotationMirrors();//获取方法的Annotations
                note("--as=" as); 
                for(AnnotationMirror am:as){
                    //获取Annotation的值
                    Map<? extends ExecutableElement, ? extends AnnotationValue> map= am.getElementValues();
                    Set<? extends ExecutableElement> ks = map.keySet();
                    for(ExecutableElement k:ks){//打印Annotation的每个值
                        AnnotationValue av = map.get(k);
                        note("----" ee.getSimpleName() "." k.getSimpleName() "=" av.getValue());
                    }
                }
            }
        }
        return false;
    }
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface ToBeTested{
    String owner() default "Chinajash";
    String group();
}

编写翻译以上代码,然后再创立上面包车型地铁Testing对象,不要编写翻译Testing对象,小编在前面会编写翻译它

public class Testing{    
    @ToBeTested(group="A")
    public void m1(){
    }
    @ToBeTested(group="B",owner="QQ")
    public void m2(){
    }    
    @PostConstruct//Common Annotation里面的一个Annotation
    public void m3(){
    }    
}

下边作者用以下命令编写翻译Testing对象

javac -XprintRounds -processor PluggableAPT.MyAnnotationProcessor Testing.java

-XprintRounds表示打字与印刷round的次数,运营方面命令后在支配台会看到如下输出:

Round 1:
        input files: {PluggableAPT.Testing}
        annotations: [PluggableAPT.ToBeTested, javax.annotation.PostConstruct]
        last round: false
Note: annotation:PluggableAPT.ToBeTested
Note: --ExecutableElement name is m1
Note: ")
Note: ----m1.group=A
Note: --ExecutableElement name is m2
Note: ", owner="QQ")
Note: ----m2.group=B
Note: ----m2.owner=QQ
Note: --ExecutableElement name is m3
Note: --as=@javax.annotation.PostConstruct
Round 2:
        input files: {}
        annotations: []
        last round: true

本来想用JDK陆.0的Compiler API来实施上边编写翻译命令,可是好像以后Compiler API还不辅助-processor参数,运营时总报以下错误

Exception in thread "main" java.lang.IllegalArgumentException: invalid flag: -processor PluggableAPT.MyAnnotationProcessor

调用Compiler API的代码是那般的

JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
Iterable<? extends JavaFileObject> sourcefiles = fileManager.getJavaFileObjects("Testing.java");
Set<String> options = new HashSet<String>();
options.add("-processor PluggableAPT.MyAnnotationProcessor");
compiler.getTask(null, fileManager, null, options, null, sourcefiles).call();

不知道那是还是不是Compiler API的叁个bug。

 

9.Common Annotations

Common annotations原本是Java EE 伍.0(JSRubicon244)标准的1有的,今后SUN把它的一有的放到了Java SE 6.0中.
随着Annotation元数据成效(JSRubicon 175)参与到Java SE 5.0里边,诸多Java 本事(举例EJB,Web Services)都会用Annotation部分代表XML文件来安排运转参数(也许说是帮忙评释式编制程序,如EJB的评释式事务), 假诺这几个技能为通用指标都独立定义了投机的Annotations,显明不怎么重复建设, 所以,为任何连锁的Java本事定义1套公共的Annotation是有价值的,可防止止重新建设的还要,也准保Java SE和Java EE 各样手艺的完全一样性.

下边罗列出Common Annotations 1.0内部的十三个Annotations Common Annotations

Annotation Retention Target Description
Generated Source ANNOTATION_TYPE, CONSTRUCTOR, FIELD, LOCAL_VAPRADOIABLE, METHOD, PACKAGE, PARAMETE昂Cora, TYPE 用于标明生成的源代码
Resource Runtime TYPE, METHOD, FIELD 用于注明所依赖的财富,容器据此注入外部能源倚重,有依赖字段的注入和依赖setter方法的注入二种艺术
Resources Runtime TYPE 同期标明几个外表依赖,容器会把富有这个外部注重注入
PostConstruct Runtime METHOD 标记当容器注入全部注重之后运营的点子,用来开始展览注重注入后的伊始化工作,只有一个方式能够标明为PostConstruct
PreDestroy Runtime METHOD 当对象实例将要被从容器个中删掉以前,要实行的回调方法要标记为PreDestroy RunAs Runtime TYPE 用于标明用哪些安全剧中人物来推行被表明类的法子,那几个安全剧中人物必须和Container 的Security剧中人物1致的。RolesAllowed Runtime TYPE, METHOD 用于申明允许施行被标明类或措施的安全角色,那个安全剧中人物必须和Container 的Security角色一致的
PermitAll Runtime TYPE, METHOD 允许持有剧中人物施行被评释的类或格局
DenyAll Runtime TYPE, METHOD 不允许别的角色实施被标注的类或格局,申明该类或方法无法在Java EE容器里面运转
DeclareRoles Runtime TYPE 用来定义可以被应用程序核实的安全剧中人物,日常用isUserInRole来检查安全剧中人物

用Console开荒调整台程序

JDK陆中提供 了java.io.Console类专项使用来拜会基于字符的调节台设备。程序壹旦要与Windows下的cmd也许Linux下的Terminal交互,就足以用Console类代劳。但大家不总是能赢得可用的Console,一个JVM是不是有可用的Console信赖于底层平台和JVM怎么样被调用。假设JVM是在交互式命令行(比如Windows的cmd)中运维的,并且输入输出未有重定向到其它的地方,那么就可以获得一个可用的Console实例 。

Console类:

计算机编程 5

 

演示代码:

 1 import java.io.Console;
 2 
 3 public class Test {
 4     public static void main(String[] args){
 5         Console console = System.console();
 6         if(console!=null){//判断console是否可用
 7             String user = new String(console.readLine("Enter user:")); //读取整行字符
 8             String pwd = new String(console.readPassword("Enter passowrd:")); //读取密码,密码输入时不会显示
 9             console.printf("User is:" user "/n");
10             console.printf("Password is:" pwd "/n");
11         }else{
12             System.out.println("JVM无法使用当前的Console");
13         }
14     }
15 }

在AMDliJ IDEA 中平昔运营实行结果:

JVM无法使用当前的Console

在cmd里面一贯 java Test 结果:中黄字体是输入部分,密码前面输入暗许是暗藏的

F:test>java Test
Enter user:niannianjiuwang
Enter passowrd:
User is:niannianjiuwang/nPassword is:123456/n

 

注意:

a. RolesAllowed,PermitAll,DenyAll不可能而且接纳到叁个类或格局上
b. 表明在措施上的RolesAllowed,PermitAll,DenyAll会覆盖标记在类上的RolesAllowed,PermitAll,DenyAll
c. RunAs,RolesAllowed,PermitAll,DenyAll和DeclareRoles还尚无加到Java SE 陆.0上来
d. 管理以上Annotations的做事是由Java EE容器来做, Java SE 陆.0只是富含了地点表格的前多种Annotations的定义类,并从未包含管理这一个Annotations的引擎,那些工作得以由Pluggable Annotation Processing API(JSKoleos 26九)来做

转移的地点最大的正是java GUI分界面的展现了,JDK陆.0(也正是JDK一.六)帮助新型的windows vista系统的Windows Aero视窗效果,而JDK1.伍不支持!!!
你要在vista情状下编制程序的话最棒装jdk陆.0,否则它总是换来windows basic视窗效果.

对脚本语言的帮忙(如: ruby, groovy, javascript)

JDK二十四日增了对脚本语言的支撑(JSR 223),原理上是将脚本语言编写翻译成字节码,这样脚本语言也能分享Java平台的不在少数优势,包蕴可移植性,安全等,别的,由于今后是编写翻译成字节码后再实践,所以比原来边解释边实行功效要高大多。加入对脚本语言的支撑后,对

Java语言也提供了以下好处。
一、好多脚本语言都有动态特性,举个例子,你不供给用一个变量在此之前先申明它,你能够用三个变量存放完全分化门类的指标,你无需做强制类型转变,因为改换皆以半自动的。现在Java语言也能够通过对脚本语言的支撑直接得到这种灵活性。
2、能够用脚本语言赶快支付产品原型,因为今后能够艾德it-Run,而无需艾德it-Compile-Run,当然,因为Java有丰富好的IDE协理,我们完全能够在IDE里面编辑源文件,然后点击运行(隐含编写翻译),以此到达火速支付原型的目标,所以那一点好处基本上可以忽略。
叁、通过引入脚本语言可以轻巧完成Java应用程序的扩充和自定义,我们得以把原先布满在在Java应用程序中的配置逻辑,数学表达式和业务规则提抽取来,转用JavaScript来处理。

Sun的JDK陆兑现包罗了三个基于Mozilla Rhino的 脚本语言引擎,扶助JavaScript,那并不是认证JDK四头扶助JavaScript,任何第一方都能够友善达成一个JSXC60-2二三11分的脚本引擎 使得JDK陆帮忙别的脚本语言,举例,你想让JDK6扶助Ruby,那你能够谐和遵照JSLAND2二三的专门的学问落实贰个Ruby的台本引擎类,具体一点,你必要达成javax.script.ScriptEngine(轻巧起见,能够继续 javax.script.AbstractScriptEngine) 和 javax.script.ScriptEngineFactory 四个接口。当然,在您兑现谐和的脚本语引擎从前,先到 scripting.dev.java.net project 这里看望是还是不是有人曾经帮你做了办事,那样您就足以从来拿来用。

10.有局地小的改观:

Scripting API

Scripting API是用来在Java内部编写脚本语言程序的API, 在Javax.script中能够找到Scripting API,大家就算用那些API来编排JavaScript程序,那几个包里面有二个ScriptEngineManager类,它是应用Scriptng API 的进口,ScriptEngineManager能够由此Jar服务意识(service discovery)机制找出适合的剧本引擎类(ScriptEngine),使用Scripting API的最简便方法只需下边三步
壹、创立三个ScriptEngineManager对象
2、通过ScriptEngineManager获得ScriptEngine对象
三、用ScriptEngine的eval方法试行脚本

示范代码: 

 1 import javax.script.Invocable;
 2 import javax.script.ScriptEngine;
 3 import javax.script.ScriptEngineManager;
 4 
 5 public class Test {
 6     public static void main(String[] args){
 7         ScriptEngineManager factory = new ScriptEngineManager();
 8         ScriptEngine engine = factory.getEngineByName("JavaScript");
 9         String script;
10         try {
11             script = "print('Hello')";
12             engine.eval(script);// 执行脚本
13             script = "1-23*9/3 77";
14             System.out.println(engine.eval(script).toString());// 不用对字符串做解析便可得到算式结果
15             engine.put("a", "一个字符串");
16             script = "print(a)";
17             engine.eval(script);// 脚本调用java对象
18             script = "function hello(name) { return 'Hello,'   name;}";
19             engine.eval(script);
20             Invocable inv = (Invocable) engine;
21             System.out.println(inv.invokeFunction("hello", "Scripting"));//java调用脚本方法
22         } catch (Exception e) {
23             e.printStackTrace();
24         }
25     }
26 
27 }

出口结果:

Hello
9
一个字符串
Hello,Scripting

 

File类扩充了如下方法

正如方法赢得磁盘使用音讯:
getTotalSpace() - 再次来到此抽象路线名内定的分区大小。以字节为单位。
getFreeSpace() - 重临此抽象路线名钦命的分区中未分配的字节数。
getUsableSpace() - 再次来到此抽象路线名钦定的分区上可用于此虚拟机的字节数。若有希望,此方法将检查写权限和其余操作系统限制,因而与 getFreeSpace() 比较,此措施能更加纯粹地推测可实际上写入的新数据数。
一般来讲方法获得文件权限:
setWritable(boolean writable, boolean ownerOnly) 和 setWritable(boolean writable) - 设置此抽象路线名的持有者或富有用户的写权限。
setReadable(boolean readable, boolean ownerOnly) 和 setReadable(boolean readable) - 设置此抽象路线名的全部者或享有用户的读权限。
setExecutable(boolean executable, boolean ownerOnly) 和 setExecutable(boolean executable) - 设置此抽象路线名的持有者或具有用户的奉行权限。
canExecute() - 测试应用程序是还是不是能够举办此抽象路线名表示的文书。

 Common Annotations

 Common annotations原本是Java EE 伍.0(JSLacrosse24四)标准的壹局地,以往SUN把它的一片段放到了Java SE 六.0中。随着Annotation元数据作用(JS瑞虎 17伍)插足到Java SE 伍.0里面,许多Java 手艺(比如EJB,Web Services)都会用Annotation部分代表XML文件来布局运维参数(大概说是帮忙申明式编程,如EJB的证明式事务), 假如那几个技艺为通用目标都单身定义了上下一心的Annotations,分明有些重复建设, 所以,为别的相关的Java本领定义壹套公共的Annotation是有价值的,能够幸免重复建设的还要,也确定保证Java SE和Java EE 各类技术的壹致性。

上边罗列出Common Annotations 1.0中间的13个Annotations Common Annotations 

  • @Generated:生成的疏解用于标识已转移的源代码。
  • @Resource: 用于评释所重视的财富,容器据此注入外部能源依赖,有依照字段的流入和依据setter方法的注入两种形式。
  • @Resources: 同有的时候间注解多少个外表注重,容器会把富有这一个外部依赖注入 。
  • @PostConstruct:注脚当容器注入所有正视之后运营的法门,用来拓展重视注入后的初叶化学工业作,唯有三个主意能够注脚为PostConstruct 。
  • @RunAs:施行时期应用程序的剧中人物。
  • @PreDestroy:当指标实例就要被从容器个中删掉此前,要实行的回调方法要申明为RunAs用于标记用什么样安全剧中人物来执行被标明类的章程,那么些安全剧中人物必须和Container 的Security角色1致的。
  • @RolesAllowed: 用于标记允许实施被标记类或措施的三沙剧中人物,这么些安全剧中人物必须和Container 的Security剧中人物一致的 。
  • @PermitAll:允许全体剧中人物实施被标注的类或艺术 。
  • @DenyAll:不容许任何剧中人物试行被评释的类或艺术,阐明该类或艺术不能在Java EE容器里面运维 。
  • @DeclareRoles:用来定义能够被应用程序查证的平安脚色,通常用isUserInRole来调查安全剧中人物。

注意:

  1. RolesAllowed,PermitAll,DenyAll不能够同期选用到二个类或方式上 
  2. 申明在章程上的RolesAllowed,PermitAll,DenyAll会覆盖注脚在类上的RolesAllowed,PermitAll,DenyAll 
  3. RunAs,RolesAllowed,PermitAll,DenyAll和DeclareRoles还不曾加到Java SE 六.0上来 
  4. 拍卖以上Annotations的干活是由Java EE容器来做, Java SE 6.0只是包涵了上边表格的前七种Annotations的定义类,并不曾包蕴管理那个Annotations的引擎,那几个事业能够由Pluggable Annotation Processing API(JSHaval 26玖)来做

 

JDK陆 更动最大的正是java GUI界面包车型客车体现,JDK陆支撑新型的windows vista系统的Windows Aero视图效果,而JDK5不协理。

 

IOException类增添构造函数

IOException补助特别链通过新的构造函数:IOException(String, Throwable) 和IOException(Throwable)。

File.isFile()方法的一颦一笑发生变化

Windows遇到下对封存设备名如: CON, NUL, AUX, LPT, 等等,永久再次回到false。

java GUI分界面的呈现的改造

JDK陆.0(相当于JDK壹.陆)帮忙最新的windows vista系统的Windows Aero视窗效果,而JDK壹.5不扶助!!!
您要在vista际遇下编程的话最棒装jdk陆.0,不然它连接换成windows basic视窗效果.

java.nio模块,增添java.nio.channels.SelectorProvider完毕类等
参照作品:

http://www.educity.cn/java/503311.html
http://www.cnblogs.com/nayitian/p/3388000.html
http://www.jianshu.com/p/24dadca2e824

TAG标签:
版权声明:本文由澳门新葡8455手机版发布于计算机编程,转载请注明出处:JDK各样版本的新特点jdk一计算机编程,六的新特