中国领先的IT技术网站
|
|

在Java SE平台上使用Headless模式

哪里才能用到此模式呢?想想你的应用不停的生成一张图片,比如,当用户每次登陆系统是都要生成一张认证图片。当创建图片时,你得应用既不需要显示器也不需要键盘。让我们假设一下,现在你的应用有个主架构或者专有服务器,但这个服务没有显示器,键盘或者鼠标。

作者:来源:OSCHINA编译|2013-08-27 10:31

沙龙活动 | 去哪儿、陌陌、ThoughtWorks在自动化运维中的实践!10.28不见不散!


这篇文章介绍怎样在标准Java(Java SE,也称作J2SE)平台上用Headless模式。

Headless模式是在缺少显示屏、键盘或者鼠标时的系统配置。听起来不可思议,但事实上你可以在这中模式下完成不同的操作,甚至是用图形数据也可以。

哪里才能用到此模式呢?想想你的应用不停的生成一张图片,比如,当用户每次登陆系统是都要生成一张认证图片。当创建图片时,你得应用既不需要显示器也不需要键盘。让我们假设一下,现在你的应用有个主架构或者专有服务器,但这个服务没有显示器,键盘或者鼠标。理想的决定是用环境的大量视觉计算能力而不是非视觉特性。在Headless模式下生成的图片可以传递到Headful系统进行更深层次渲染。

在java.awt.toolkit和java.awt.graphicsenvironment 类中有许多方法,除了对字体,图像和打印的操作外还有调用显示器,键盘和鼠标的方法。但是有一些类中,比如Canvas 和 Panel,可以在headless模式下执行。在J2SE 1.4平台之后就提供了对Headless模式的支持。

注:这篇文章重点讲的是Java SE6 平台版本的文档。任何API增加或其他增强Java SE平台的规范由JSR270专家组(JSR 270 Expert Group.)的审查和批准

Toolkit

java.awt.Toolkit类是Abstract Window Toolkit (AWT)的 所有实现类的抽象父类。Toolkit的子类用于把各种AWT组件绑定到特定的本地toolkit实现上去。 

如果显示设备,键盘或鼠标不支持的话,很多组件都会受影响。一个合适的类构造器应当抛出一个HeadlessException异常:

  • Button
  • Checkbox
  • Choice
  • Dialog
  • FileDialog
  • Frame
  • Label
  • List
  • Menu
  • MenuBar
  • MenuItem
  • PopupMenu
  • Scrollbar
  • ScrollPane
  • TextArea
  • TextField
  • Window

这种重量级的组件需要有一个操作系统级别上对等的图形函数来支持它,在headless的机器上它们将不能正常工作。 

与Canvas、Panel和Image组件相关的组件不需要抛出HeadlessException异常,因为这些组件在操作系统级别上的对等图形函数可以使用空函数,然后作为轻量级组件来处理。

一个Headless的toolkit也会把Java组件绑定到本地资源上去,但是它只有在资源中不包含显示设备或输入设备时才会这样做。

Graphics Environment

java.awt.GraphicsEnvironment类是一个抽象类,它描述了在给定平台中,可以在Java技术中使用的由 GraphicsDevice对象和Font对象组成的集合。该GraphicsEnvironment中的资源可以是本地的也可以是远程设备。 GraphicsDevice对象可以是显示器,打印机或者图形缓存等,并且它们是Graphics2D 绘制函数的目标。每一个GraphicsDevice都有许多与之关联的GraphicsConfiguration对象。这些对象指定了不同的配置环境,在这些配置环境中可以使用GraphicsDevice。

Table 1 显示GraphicsEnvironment 方法,检查Headless模式支持

Table 1.  Headless 模式方法   

方法 描述

public static boolean
isHeadless()

测试环境是否为headless, 对于是否不支持display  device,keyboard,mouse。如果这个方法returns true,theToolkitandGraphicsEnvironmentclasses 抛出(thrown)依赖于display device, keyboard, mouse的aHeadlessExceptionis异常.

public boolean
isHeadlessInstance()

Returns  thisGraphicsEnvironmentcan 是否支持dieplay device,keyboard,mouse. 如果这个方法 returns  true,  theGraphicsEnvironmentthat 抛出(throw)一个依赖于 display device, keyboard, mouse的aHeadlessExceptionis 异常.

注意:isHeadless()方法检查特定的系统属性,java.awt.headless而不是系统的硬件配置.

HeadlessException 抛出的代码,这取决于display device、keyboard、mouse在一个环境称为不支持任何这些.唯一的例外是来自一个 UnsupportedOperationException,本身就是来源于一个RuntimeException.

设置Headless模式

使用Headless模式操作,您必须首先了解如何检查和设置系统属性与此相关的模式。此外,你必须了解如何创建一个默认的工具包使用工具箱的无头实现类.

系统属性配置

为了启用headless模式,需要使用setProperty()方法去设置相应的系统属性。本方法可以让你用期望的值来设置系统属性。

  1. System.setProperty("java.awt.headless""true"); 

上面的代码中,java.awt.headless是一个系统属性,true是我们设定的值。

如果你想在一个相同的程序中使用headless和传统环境,你可以使用下面的命令行来完成:

  1. java -Djava.awt.headless=true   

创建默认Toolkit

如果名字为java.awt.headless的系统属性被设置为true,那么headless工具包就会被使用。接下来使用getDefaultToolkit()方法来创建一个headless toolkit的实例:

  1. Toolkit tk = Toolkit.getDefaultToolkit(); 

Headless模式检查

要检查Headless模式的可用性,使用GraphicsEnvironment类的isHeadless()方法:

  1. GraphicsEnvironment ge =  
  2. GraphicsEnvironment.getLocalGraphicsEnvironment();  
  3. boolean headless_check = ge.isHeadless(); 

该方法检查java.awt.headless系统属性。如果这个属性有一个为true的值,那么就会从工具包和依赖于一个显示器,键盘,鼠标的GraphicsEnvironment类的区域中抛出一个HeadlessException。
在Headless模式中操作

设置好headless模式并创建一个headless工具包的实例后,您的应用程序可以执行以下操作:

  • 创建轻量级组件,如Canvas,Panel,和Swing组件,除了top级别.
  • 收集关于可用的字体、字体指标和字体设置的信息
  • 设置颜色来渲染文本和图形
  • 创造和获取图像,为渲染准备图片
  • 使用java.awt.PrintJob, java.awt.print.*, 和 javax.print.* 类进行打印。
  • 发出"哔哔"音频。

Canvas(画布)

下面的代码会在屏幕上绘制出一个空白的矩形区域,你可以在上面绘制线条。可以使用Canvas类创建一个新的Canvas组件。

  1. final Canvas c = new Canvas()  
  2. {  
  3.     public void paint(Graphics g)  
  4.     {  
  5.         Rectangle r = getBounds();  
  6.         g.drawLine(00, r.width - 1, r.height - 1);  
  7.         g.drawLine(0, r.height - 1, r.width - 10);  
  8.     }  
  9. }; 

Fonts(字体)

这段代码显示了怎么使用Font类画一个文本字符串并设置文字的字体。Graphics对象是用来绘制这个字符串的。

  1. public void paint(Graphics g)  
  2. {  
  3.     g.setFont(new Font("Arial", Font.ITALIC, 12));  
  4.     g.drawString("Test"328);  
  5. }  

Colors

这段代码显示了如何使用指定的红,绿,蓝的值来设置一条线的颜色。Graphics对象是用来绘制这条线的。

  1. public void paint(Graphics g)  
  2. {  
  3.     g.setColor(new Color(2551270));  
  4.     g.drawLine(0, r.height - 1, r.width - 10);  

Images

在下面的代码中,javax.imageio.ImageIO类的使用read()方法对图1所示的grapefruit.jpg文件进行解码,并返回一个缓存图片。

  1. Image i = null;  
  2. try 
  3. {  
  4.     File f = new File("grapefruit.jpg");  
  5.     i = ImageIO.read(f);  
  6. }  
  7. catch (Exception z)  
  8. {  
  9.     z.printStackTrace(System.err);  

图1。grapefruit.jpg图像文件

Print

这段代码演示了如何打印已经准备好的画布,你可以使用paint方法自定义打印机的的默认画面。

  1. PrinterJob pj = PrinterJob.getPrinterJob();  
  2. pj.setPrintable(new Printable()  
  3. {  
  4.    public int print(Graphics g, PageFormat pf, int pageIndex)  
  5.    {  
  6.        if (pageIndex > 0)  
  7.        {  
  8.            return Printable.NO_SUCH_PAGE;  
  9.        }  
  10.  
  11.        ((Graphics2D)g).translate(pf.getImageableX(),  
  12.                                  pf.getImageableY());  
  13.  
  14.        // Paint canvas.  
  15.        c.paint(g);  
  16.  
  17.        return Printable.PAGE_EXISTS;  
  18.    }  
  19. }); 

Beep

下面的这段代码展示了如果使用 Toolkit类的beep方法发出嘟嘟声。

  1. Toolkit tk = Toolkit.getDefaultToolkit();  
  2. tk.beep();  

使用Headless模式简单例子

以下的HeadlessBasics例子运用了文章中描述的所有功能。

要运行这个的例子,需要用javac对下面的代码进行编译。复制grapefruit.jpg图片文件到HeadlessBasics类所在的目录下面。

  1. import java.awt.*;  
  2. import java.io.*;  
  3. import java.awt.print.*;  
  4.  
  5. import javax.imageio.*;  
  6.  
  7. public class HeadlessBasics  
  8. {  
  9.     public static void main(String[] args)  
  10.     {  
  11.         // Set system property.  
  12.         // Call this BEFORE the toolkit has been initialized, that is,  
  13.         // before Toolkit.getDefaultToolkit() has been called.  
  14.         System.setProperty("java.awt.headless""true");  
  15.  
  16.         // This triggers creation of the toolkit.  
  17.         // Because java.awt.headless property is set to true, this  
  18.         // will be an instance of headless toolkit.  
  19.         Toolkit tk = Toolkit.getDefaultToolkit();  
  20.         // Standard beep is available.  
  21.         tk.beep();  
  22.  
  23.         // Check whether the application is  
  24.         // running in headless mode.  
  25.         GraphicsEnvironment ge =  
  26.         GraphicsEnvironment.getLocalGraphicsEnvironment();  
  27.         System.out.println("Headless mode: " + ge.isHeadless());  
  28.  
  29.         // No top levels are allowed.  
  30.         boolean created = false;  
  31.         try 
  32.         {  
  33.             Frame f = new Frame("Frame");  
  34.             created = true;  
  35.         }  
  36.         catch (Exception z)  
  37.         {  
  38.             z.printStackTrace(System.err);  
  39.             created = false;  
  40.         }  
  41.         System.err.println("Frame is created: " + created);  
  42.  
  43.         // No other components except Canvas and Panel are allowed.  
  44.         created = false;  
  45.         try 
  46.         {  
  47.             Button b = new Button("Button");  
  48.             created = true;  
  49.         }  
  50.         catch (Exception z)  
  51.         {  
  52.             z.printStackTrace(System.err);  
  53.             created = false;  
  54.         }  
  55.         System.err.println("Button is created: " + created);  
  56.           
  57.         // Canvases can be created.  
  58.         final Canvas c = new Canvas()  
  59.         {  
  60.             public void paint(Graphics g)  
  61.             {  
  62.                 Rectangle r = getBounds();  
  63.                 g.drawLine(00, r.width - 1, r.height - 1);  
  64.                 // Colors work too.  
  65.                 g.setColor(new Color(2551270));  
  66.                 g.drawLine(0, r.height - 1, r.width - 10);  
  67.                 // And fonts  
  68.                 g.setFont(new Font("Arial", Font.ITALIC, 12));  
  69.                 g.drawString("Test"328);  
  70.             }  
  71.         };  
  72.         // And all the operations work correctly.  
  73.         c.setBounds(3232128128);  
  74.  
  75.         // Images are available.  
  76.         Image i = null;  
  77.         try 
  78.         {  
  79.             File f = new File("grapefruit.jpg");  
  80.             i = ImageIO.read(f);  
  81.         }  
  82.         catch (Exception z)  
  83.         {  
  84.             z.printStackTrace(System.err);  
  85.         }  
  86.         final Image im = i;  
  87.           
  88.         // Print system is available.  
  89.         PrinterJob pj = PrinterJob.getPrinterJob();  
  90.         pj.setPrintable(new Printable()  
  91.         {  
  92.             public int print(Graphics g, PageFormat pf, int pageIndex)  
  93.             {  
  94.                 if (pageIndex > 0)  
  95.                 {  
  96.                     return Printable.NO_SUCH_PAGE;  
  97.                 }  
  98.                 ((Graphics2D)g).translate(pf.getImageableX(),  
  99.                                           pf.getImageableY());  
  100.  
  101.                 // Paint the canvas.  
  102.                 c.paint(g);  
  103.  
  104.                 // Paint the image.  
  105.                 if (im != null)  
  106.                 {  
  107.                     g.drawImage(im, 32326464null);  
  108.                 }  
  109.  
  110.                 return Printable.PAGE_EXISTS;  
  111.             }  
  112.         });  
  113.         try 
  114.         {  
  115.             pj.print();  
  116.         }  
  117.         catch (Exception z)  
  118.         {  
  119.             z.printStackTrace(System.err);  
  120.         }  
  121.     }  
  122. }  

图2显示了这个例子中的打印输出结果

图2。HeadlessBasics的打印输出。

此外,你可以看到以下的信息:

  1. Headless mode: true 
  2. java.awt.HeadlessException  
  3. at java.awt.GraphicsEnvironment.checkHeadless(Unknown Source)  
  4. at java.awt.Window.<init>(Unknown Source)  
  5. at java.awt.Frame.<init>(Unknown Source)  
  6. at HeadlessBasics.main(HeadlessBasics.java:24)  
  7. Frame is created: false 
  8. java.awt.HeadlessException  
  9. at java.awt.GraphicsEnvironment.checkHeadless(Unknown Source)  
  10. at java.awt.Button.<init>(Unknown Source)  
  11. at HeadlessBasics.main(HeadlessBasics.java:39)  
  12. Button is created: false 

注:出于演示的目的,最初的代码会导致此应用程序抛出2个java.awt.HeadlessExceptions异常。

作为上一种方式的替代,你可以把标准输出信息放到一个文件中,然后把文件打印出来。在这种情况下,使用下面的命令行来运行这个例子:

java HeadlessBasics 2> standard_output.txt

把现有的应用程序转换为Headless模式。

你怎么把现有的应用程序转换为可执行的headless模式?要执行此转换的最有效的方法是分析你的源代码以确定任何的功能都是依赖于Headless模式的。换句话说,要实现相同的功能,你必须找到那些会抛出HeadlessException异常的类和方法,然后使用独立的headless模式替换这些类和方法。

你可以使用Java SE 6 API说明来判断一个特定的类或方法是否支持headless模式。如果一个特定的组件不支持headless模式,你的程序需要捕获的唯一的异常是 HeadlessException。它会在其它可能的异常之前被抛出。这也是为什么在本节的代码示例"举例: 使用Headless模式"中,没有什么特殊的必要性来捕获其它异常。

你肯定会发现其它有用的方法来使用headless模式带来的好处。我们希望本文能帮你完成此项任务,在Java SE平台中玩出一片新天地。

获取更多信息

AWT Enhancements in J2SE 1.4: Headless Support

J2SE 1.4 platform documentation: HeadlessException

The New Modality API in Java SE 6

The java.awt.Toolkit Class

The java.awt.GraphicsEnvironment Class

关于作者

Artem Ananiev 是位于 Saint Petersburg的Sun Microsystems公司的一名软件工程师,俄罗斯人。之前他曾经在Abstract Window Toolkit (AWT) 项目中工作过几年,他主要的技能领域是模态,机器人和多屏系统。

Alla Redko  是位于 Saint Petersburg的 Sun Microsystems公司的技术作者,俄罗斯人。她为AWT项目编写技术文档,并且负责更新Java用户手册。在到Sun任职之前,她已经作为技术作者工作了八年。

英文原文:Using Headless Mode in the Java SE Platform

译文链接:http://www.oschina.net/translate/using-headless-mode-in-java-se

【编辑推荐】

  1. Web应用的缓存设计模式
  2. 《大话设计模式》Python版代码实现
  3. Java多线程设计模式之线程池模式
  4. 设计模式之总结与回顾
  5. 从面向对象的设计模式看软件设计
【责任编辑:小林 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢

读 书 +更多

Linux安全体系分析与编程

本书选择经典的开放源代码,全面系统地分析了Linux安全机制。本书共有17章,前10章着重介绍了Linux操作系统的安全机制及实现方法,阐述了公...

订阅51CTO邮刊

点击这里查看样刊

订阅51CTO邮刊
× Python最火的编程语言