[关闭]
@lambeta 2016-09-20T03:36:12.000000Z 字数 20226 阅读 257

附录B

translation

附录 B

Swing中的线程

Swing是一个平台独立，基于模型-视图-控制器的GUI工具集，它被用来创建Java应用程序的图形界面。在本附录中，我首先会探索Swing的线程架构，之后会探索Swing的API，这些API用于防止在图形上下文中使用额外线程导致的问题。最后，我给出一个基于Swing的幻灯片应用程序作为本附录内容的重要例子，同时用这种好玩的方式结束本书。

注意 我会假设你对Swing的API及其应用程序的架构有一定的经验。

单线程编程模型

Swing遵循单线程编程模型。它被设计成单线程而非多线程的原因在于设计多线程图形工具集的经验已经表明多线程必然会导致死锁和竞态条件。如果想了解更多相关问题，可以查看“为何GUIs是单线程的？”博客（http://codeidol.com/java/java-concurrency/GUI-Applications/Why-are-GUIs-Single-threaded/）

用于渲染图像和处理事件的线程被称为事件-分派（event-dispatch）线程（EDT）。EDT处理来自底层抽象窗口工具集的事件队列中事件，同时调用GUI组件（例如按钮）的事件监听器，这些监听器在此线程上处理事件。组件甚至会在EDT上重绘它们自身（响应paint()方法调用时会导致paintComponent()、paintBorder()、paintChildren()方法被调用）。

一定得小心关注你的代码如何同EDT交互，确保Swing程序能正确工作。有两条原则需要记住：

单线程的Swing导致的一个结果就是你只能在EDT上创建Swing应用程序的GUI。在其它线程中创建GUI是不对的，包括用于运行Java应用程序中main()方法的默认主线程。

大部分Swing对象（如javax.swing.JFrame对象，描述了GUI中拥有菜单条和边界的顶级“框架”窗口）都不是线程安全的。从多条线程中访问这些对象会招致线程干涉的风险或者内存不一致的错误：

如果GUI不是在EDT之上创建的会发生什么问题呢？John Zukowski在JavaWorld上发表的《SWing线程化以及事件分派线程》一文中给出了一个场景。（www.javaworld.com/article/2077754/core-java/swing-threading-and-the-event-dispatch-thread.html）。

Zukowski展示了一个例子，往frame窗口容器组件中添加一个容器的监听器。当组件从frame当中添加或者移除时，监听器的方法就会被调用。他演示了默认主线程意识到frame窗口之前，EDT在监听器方法中已经开始运行代码。

注意 能被感知到意味着一个组件的paint()方法要么已经被调用，要么可能被调用。frame窗口中setVisible(true)、show()和pack()其中任意一个方法在该容器组件上被调用，这个frame窗口就被感知到了。在frame窗口被感知之后，所有它包含的组件也都被感知到了。另外一种感知组件的方式就是把它添加到已经被感知的容器当中。

EDT在一个监听器方法中开始运行之后，如果默认主线程继续初始化GUI，组件可能会被默认主线程创建并被EDT访问。EDT可能试图在这些组件存在之前访问它们。这样做可能会使应用程序崩溃。

即便在EDT从监听器方法中访问这些组件之前，默认主线程创建了它们，EDT还是可能看到不一致的视图（由于缓存）而无法访问指向新组件的引用。应用程序崩溃（可能抛出java.lang.NullPointerException对象）十有八九会发生。

清单B-1展示了ViewPage的源码，即一个浏览web页面HTML的Swing应用程序。这个应用程序就遭受了以上两个问题。

清单B-1 一个有问题的Swing应用，用于浏览Web页面HTML

  1. import java.awt.BorderLayout;
  2. import java.awt.Dimension;
  3. import java.awt.EventQueue;
  4. import java.awt.event.ActionEvent;
  5. import java.awt.event.ActionListener;
  6. import java.io.InputStream;
  7. import java.io.IOException;
  8. import java.net.URL;
  9. import javax.swing.JFrame;
  10. import javax.swing.JLabel;
  11. import javax.swing.JPanel;
  12. import javax.swing.JScrollPane;
  13. import javax.swing.JTextArea;
  14. import javax.swing.JTextField;
  16. public class ViewPage
  17. {
  18.     public static void main(String[] args)
  19.     {
  20.         final JFrame frame = new JFrame("View Page");
  21.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  22.         JPanel panel = new JPanel();
  23.         panel.add(new JLabel("Enter URL"));
  24.         final JTextField txtURL = new JTextField(40);
  25.         panel.add(txtURL);
  26.         frame.getContentPane().add(panel, BorderLayout.NORTH);
  27.         final JTextArea txtHTML = new JTextArea(10, 40);
  28.         frame.getContentPane().add(new JScrollPane (txtHTML),
  29.                                             BorderLayout.CENTER);
  30.         ActionListener al = (ae) ->
  31.                 {
  32.                     InputStream is = null;
  33.                     try
  34.                     {
  35.                         URL url = new URL(txtURL.getText());
  36.                         is = url.openStream();
  37.                         StringBuilder sb = new StringBuilder();
  38.                         int b;
  39.                         while ((b = is.read()) != -1)
  40.                             sb.append((char) b);
  41.                         txtHTML.setText(sb.toString());
  42.                     }
  43.                     catch (IOException ioe)
  44.                     {
  45.                         txtHTML.setText(ioe.getMessage());
  46.                     }
  47.                     finally 
  48.                     {
  49.                         txtHTML.setCaretPosition(0);
  50.                         if (is != null)
  51.                         try 
  52.                         {
  53.                             is.close();
  54.                         }
  55.                         catch (IOException ioe)
  56.                         {
  57.                         }
  58.                     } 
  59.                 };
  60.                 txtURL.addActionListener(al);
  61.                 frame.pack();
  62.                 frame.setVisible(true);
  63.     } 
  64. }

清单B-1中的main()方法创建了一个GUI，它由一个用于输入web页面URL的文本框以及一个用于显示页面HTML的可滚动文本区域组成。在输入URL之后按下回车键，触发ViewPage获取并显示HTML。

照下面编译清单B-1：

  1. javac ViewPage.java

运行程序：

  1. java ViewPage

你应该能观测到如图B-1展示的GUI（由一个样例URL和部分结果web页面的HTML构成）。

[图]

图B-1. 文本框输入一个URL并且在可滚动文本区域浏览web页面输出

该应用程序的第一个问题是GUI在默认的主线程被创建出来而非EDT。尽管再运行ViewPage时你可能不会遇到问题，但是依然会有潜在的线程干涉以及内存不一致问题。

第二个问题是那个运行动作监听器的EDT，它用于响应文本框之上按下回车的操作。针对这个URL打开一个input stream及读取其内容到一个string builder中的代码会推迟EDT。GUI在此期间不会响应。

线程化APIs

Swing提供了一系列的API用于克服前面提及的EDT的问题。本章节中，我会介绍这些API。同时，我也会介绍Swing版本的定时器，它和第4章中展示的定时器框架有很大不同。

SwingUtilities和EventQueue

类javax.swing.SwingUtilities提供了一组在Swing上下文中很有用的静态方法。其中有三个对于使用EDT和避免提及的问题很管用：

invokeAndWait()、invokeLater()以及isEventDispatchThread()方法就是调用类java.awt.EventQueue中同等方法的包装器。尽管你给这些方法加上SwingUtilities的前缀，而我则使用EventQueue作为前缀（出于习惯）。

你通常会根据以下模式使用invokeLater()方法构建一个Swing的GUI：

  1. Runnable r = ... // ... refers to the runnable's anonymous class or lambda
  2. EventQueue.invokeLater(r);

清单B-2展示了第二版ViewPage的源代码，它使用了invokeLater()方法在EDT之上构造了Swing GUI。

清单B-2 在EDT之上构造HTML查看器的Swing应用程序的GUI

  1. import java.awt.BorderLayout;
  2. import java.awt.Dimension;
  3. import java.awt.EventQueue;
  4. import java.awt.event.ActionEvent;
  5. import java.awt.event.ActionListener;
  6. import java.io.InputStream;
  7. import java.io.IOException;
  8. import java.net.URL;
  9. import javax.swing.JFrame;
  10. import javax.swing.JLabel;
  11. import javax.swing.JPanel;
  12. import javax.swing.JScrollPane;
  13. import javax.swing.JTextArea;
  14. import javax.swing.JTextField;
  16. public class ViewPage
  17. {
  18.     public static void main(String[] args)
  19.     {
  20.         Runnable r = () ->
  21.         {
  22.             final JFrame frame = new JFrame("View Page");
  23.             frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  24.             JPanel panel = new JPanel();
  25.             panel.add(new JLabel("Enter URL"));
  26.             final JTextField txtURL = new JTextField(40);
  27.             panel.add(txtURL);
  28.             frame.getContentPane().add(panel, BorderLayout.NORTH);
  29.             final JTextArea txtHTML = new JTextArea(10, 40);
  30.             frame.getContentPane().add(new JScrollPane (txtHTML),
  31.                                                 BorderLayout.CENTER);
  32.             ActionListener al = (ae) ->
  33.             {
  34.                 InputStream is = null;
  35.                 try
  36.                 {
  37.                     URL url = new URL(txtURL.getText());
  38.                     is = url.openStream();
  39.                     StringBuilder sb = new StringBuilder();
  40.                     int b;
  41.                     while ((b = is.read()) != -1)
  42.                         sb.append((char) b);
  43.                     txtHTML.setText(sb.toString());
  44.                 }
  45.                 catch (IOException ioe)
  46.                 {
  47.                     txtHTML.setText(ioe.getMessage());
  48.                 }
  49.                 finally 
  50.                 {
  51.                     txtHTML.setCaretPosition(0);
  52.                     if (is != null)
  53.                     try 
  54.                     {
  55.                         is.close();
  56.                     }
  57.                     catch (IOException ioe)
  58.                     {
  59.                     }
  60.                 }
  61.             };
  63.             txtURL.addActionListener(al);
  64.             frame.pack();
  65.             frame.setVisible(true);     
  66.         };
  68.         EventQueue.invokeLater(r); 
  69.     }
  70. }

清单B-2解决了一个问题，但是我们依旧得防止EDT被延迟。我们可以通过在EDT之上创建一条工作线程去读取页面，而后使用invokeAndWait()方法把页面内容更新到滚动的文本区域来解决这一问题。

清单B-3 在非延迟的EDT之上构造HTML查看器的Swing应用程序的GUI

  1. import java.awt.BorderLayout;
  2. import java.awt.Dimension;
  3. import java.awt.EventQueue;
  4. import java.awt.event.ActionEvent;
  5. import java.awt.event.ActionListener;
  6. import java.io.InputStream;
  7. import java.io.IOException;
  8. import java.lang.reflect.InvocationTargetException;
  9. import java.net.URL;
  10. import javax.swing.JFrame;
  11. import javax.swing.JLabel;
  12. import javax.swing.JPanel;
  13. import javax.swing.JScrollPane;
  14. import javax.swing.JTextArea;
  15. import javax.swing.JTextField;
  17. public class ViewPage
  18. {
  19.     public static void main(String[] args)
  20.     {
  21.         Runnable r = () ->
  22.         {
  23.             final JFrame frame = new JFrame("View Page");
  24.             frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  25.             JPanel panel = new JPanel();
  26.             panel.add(new JLabel("Enter URL"));
  27.             final JTextField txtURL = new JTextField(40);
  28.             panel.add(txtURL);
  29.             frame.getContentPane().add(panel, BorderLayout.NORTH);
  30.             final JTextArea txtHTML = new JTextArea(10, 40);
  31.             frame.getContentPane().add(new JScrollPane (txtHTML),
  32.                                                 BorderLayout.CENTER);
  33.             ActionListener al = (ae) ->
  34.             {
  35.                 txtURL.setEnabled(false); 
  36.                 Runnable worker = () ->
  37.                 {
  38.                     InputStream is = null;
  39.                     try
  40.                     {
  41.                         URL url = new URL(txtURL.getText());
  42.                         is = url.openStream();
  43.                         final StringBuilder sb = new StringBuilder();
  44.                         int b;
  45.                         while ((b = is.read()) != -1)
  46.                             sb.append((char) b);
  47.                         Runnable r1 = () ->
  48.                         {
  49.                             txtHTML.setText(sb.toString());
  50.                             txtURL.setEnabled(true);
  51.                         };
  52.                         try 
  53.                         {
  54.                             EventQueue.invokeAndWait(r1); }
  55.                         catch (InterruptedException ie)
  56.                         {
  57.                         }
  58.                         catch (InvocationTargetException ite)
  59.                         {
  60.                         }
  61.                     }
  62.                     catch (final IOException ioe)
  63.                     {
  64.                         Runnable r1 = () ->
  65.                         {
  66.                             txtHTML.setText(ioe.getMessage());
  67.                             txtURL.setEnabled(true);
  68.                         };
  70.                         try {
  71.                             EventQueue.invokeAndWait(r1); }
  72.                         catch (InterruptedException ie)
  73.                         {
  74.                         }
  75.                         catch (InvocationTargetException ite)
  76.                         {
  77.                         } 
  78.                     }
  79.                     finally 
  80.                     {
  81.                         Runnable r1 = () ->
  82.                         {
  83.                             txtHTML.setCaretPosition(0);
  84.                             txtURL.setEnabled(true);
  85.                         };
  86.                         try
  87.                         {
  88.                             EventQueue.invokeAndWait(r1); }
  89.                         catch (InterruptedException ie)
  90.                         {
  91.                         }
  92.                         catch (InvocationTargetException ite)
  93.                         {
  94.                         }
  95.                         if (is != null)
  96.                             try 
  97.                             {
  98.                                 is.close();
  99.                             }
  100.                             catch (IOException ioe)
  101.                             {
  102.                             }
  103.                     }
  104.                 };
  105.                 new Thread(worker).start();
  106.             };
  108.             txtURL.addActionListener(al);
  109.             frame.pack();
  110.             frame.setVisible(true);
  111.         };
  112.         EventQueue.invokeLater(r);
  113.     }
  114. }

我在获取页面时禁用文本框而后再启用。而你仍然可以在任意时刻关闭GUI。

尽管清单B-3解决了GUI无响应的问题，但是解决方案还是稍微冗余了点。幸运的是，这儿有替代方案。

SwingWorker

Swing提供了类javax.swing.SwingWorker以较少的冗余来容纳长时间运行的任务（如读取URL的内容）。你必须继承这个抽象类并重写一个或多个方法来有效地完成工作。

SwingWorker的泛型类型是SwingWorker<T, V>。参数T和V区分了最终以及中间任务的结果类型。

你可以重写protected abstract T doInBackground()方法在一条工作线程中执行长时间的任务并且返回一个T类型的结果（当没有结果时，返回Void类型）。当该方法结束，protected void done()方法就会在EDT上被调用。默认情况下，该方法不做任何事。不过，你也可以重写done()方法来安全地更新GUI。

当任务在运行时，你可以通过调用protected void publish(V... chunks)方法周期性地将结果发布到EDT中。这些结果会被运行在EDT中重写过的protected void process(List<V> chunks)方法获取到。如果没有中间结果需要处理，你可以为V指定Void类型（或者不使用publish()及process()方法）。

SwingWorker有两个及以上的方法需要你了解。首先，void execute()方法在一条工作线程调度被调用的SwingWorker对象。其次，T get()方法在需要时会等待doInBackground()方法完成，而后返回最终结果。

注意 尝试获取从doInBackground()方法中获取对象过程中如果发生异常，那么SwingWorker的get()方法就会抛出类java.util.concurrent.ExecutionException的实例。它也可以抛出InterruptedException。

清单B-4展示了最终ViewPage应用程序的源码，它使用SwingWorker取代了invokeAndWait()方法。

清单B-4 重新在非延迟的EDT之上构造HTML查看器的Swing应用程序的GUI

  1. import java.awt.BorderLayout;
  2. import java.awt.Dimension;
  3. import java.awt.EventQueue;
  4. import java.awt.event.ActionEvent;
  5. import java.awt.event.ActionListener;
  6. import java.io.InputStream;
  7. import java.io.IOException;
  8. import java.net.URL;
  9. import java.util.concurrent.ExecutionException;
  10. import javax.swing.JFrame;
  11. import javax.swing.JLabel;
  12. import javax.swing.JPanel;
  13. import javax.swing.JScrollPane;
  14. import javax.swing.JTextArea;
  15. import javax.swing.JTextField;
  16. import javax.swing.SwingWorker;
  18. public class ViewPage
  19. {
  20.     public static void main(String[] args)
  21.     {
  22.         Runnable r = () ->
  23.         {
  24.             final JFrame frame = new JFrame("View Page");
  25.             frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  26.             JPanel panel = new JPanel();
  27.             panel.add(new JLabel("Enter URL"));
  28.             final JTextField txtURL = new JTextField(40);
  29.             panel.add(txtURL);
  30.             frame.getContentPane().add(panel, BorderLayout.NORTH);
  31.             final JTextArea txtHTML = new JTextArea(10, 40);
  32.             frame.getContentPane().add(new JScrollPane (txtHTML),
  33.                                                 BorderLayout.CENTER);
  34.             ActionListener al = (ae) ->
  35.             {
  36.                 txtURL.setEnabled(false);
  37.                 class GetHTML extends SwingWorker<StringBuilder, Void>
  38.                 {
  39.                     private final String url;
  40.                     GetHTML(String url)
  41.                     {
  42.                         this.url = url;
  43.                     }
  44.                     @Override
  45.                     public StringBuilder doInBackground()
  46.                     {
  47.                         StringBuilder sb = new StringBuilder();
  48.                         InputStream is = null;
  49.                         try
  50.                         {
  51.                             URL url = new URL(this.url);
  52.                             is = url.openStream();
  53.                             int b;
  54.                             while ((b = is.read()) != -1)
  55.                                 sb.append((char) b);
  56.                             return sb;
  57.                         }
  58.                         catch (IOException ioe)
  59.                         {
  60.                             sb.setLength(0);
  61.                             sb.append(ioe.getMessage());
  62.                             return sb;
  63.                         } 
  64.                         finally 
  65.                         {
  66.                             if (is != null)
  67.                                 try
  68.                                 {
  69.                                     is.close();
  70.                                 }
  71.                                 catch (IOException ioe)
  72.                                 {
  73.                                 }
  74.                         }
  75.                     }
  77.                     @Override
  78.                     public void done()
  79.                     {
  80.                         try 
  81.                         {
  82.                             StringBuilder sb = get();
  83.                             txtHTML.setText(sb.toString());
  84.                             txtHTML.setCaretPosition(0);
  85.                         }
  86.                         catch (ExecutionException ee)
  87.                         {
  88.                             txtHTML.setText(ee.getMessage());
  89.                         }
  90.                         catch (InterruptedException ie)
  91.                         {
  92.                             txtHTML.setText("Interrupted");
  93.                         }
  95.                         txtURL.setEnabled(true);
  96.                     }
  97.                 }
  98.                 new GetHTML(txtURL.getText()).execute();
  99.             };
  101.             txtURL.addActionListener(al);
  102.             frame.pack();
  103.             frame.setVisible(true);
  104.         };
  105.         EventQueue.invokeLater(r);
  106.     }
  107. }

最终版本的ViewPage依赖于GetHTML这个声明在动作监听器lambda表达式中的本地SwingWorker子类，用于在工作线程中读取web页面（保持用户持续响应），然后用HTML更新EDT（Swing的代码必须在这里执行）之上的用户界面。

当lambda表达式运行时（用户在文本框中输入一个URL之后按下回车键），它用文本框中的文本初始化了GetHTML类（由于Swing是单线程的，所以无法从工作线程中访问文本框）并且调用了SwingWorker的execute()方法。

execute()方法导致GetHTML中重写的doInBackground()方法在工作线程中被调用，这会产生并返回一个包裹HTML或者错误文本的java.lang.StringBuilder对象。EDT之后会调用重写的done()方法，该方法会调用SwingWorker的get()方法访问这个StringBuilder对象并且把内容输出到文本区域。

定时器

Swing提供了类javax.swing.Timer（很像一个简化版的定时器框架——请见第4章）在EDT上周期性地执行Swing的代码。它会在一个初始的延时之后触发一个动作事件到注册过的监听器当中，并且此后以固定的事件间隔重复触发。

调用构造函数Timer(int delay, ActionListener listener)创建一个有初始延时以及事件间隔延时的定时器，并且每隔delay毫秒，事件就会被发送到初始的动作监听器（可能为空）中。

delay这个参数值会被用于初始延时以及固定的事件间隔。当然你也可以分别将这些值通过void setInitialDelay(int initialDelay)和void setDelay(int delay)方法设置进去。

注意 用false作为参数调用Timer的void setRepeats(boolean flag)方法会导致该定时器仅发送一条动作事件。

调用void addActionListener(ActionListener listener)方法可以添加另外一个动作监听器，而调用void removeActionListener(ActionListener listener)方法则移除了之前注册的动作监听器。调用ActionListener[] getActionListeners()方法会获取所有注册的监听器。

新创建的定时器处于停止状态。为了启动这个定时器，需要调用其void start()方法。相对地，你需要调用void stop()方法来终止这个定时器。你或许也想要调用boolean isRunning()方法来确定这个定时器是否正在运行。

清单B-5展示了一个计数器应用程序的源码，它会创建一个定时器来持续地在一个标签（label）上显示跳动的计数。

清单B-5 开始和停止计数

  1. import java.awt.EventQueue;
  2. import java.awt.FlowLayout;
  3. import java.awt.event.ActionListener;
  4. import javax.swing.JButton;
  5. import javax.swing.JFrame;
  6. import javax.swing.JLabel;
  7. import javax.swing.JPanel;
  8. import javax.swing.Timer;
  10. public class Counter extends JFrame
  11. {
  12.     int count;
  14.     public Counter(String title)
  15.     {
  16.         super(title);
  17.         setDefaultCloseOperation(EXIT_ON_CLOSE);
  18.         JPanel pnl = new JPanel();
  19.         ((FlowLayout) pnl.getLayout()).setHgap(20);
  20.         final JLabel lblCount = new JLabel("");
  21.         pnl.add(lblCount);
  22.         final JButton btnStartStop = new JButton("Start");
  23.         ActionListener al = (ae) ->
  24.         {
  25.             ++count;
  26.             lblCount.setText(count + " ");
  27.         };
  29.         final Timer timer = new Timer(30, al);
  31.         al = (ae) ->
  32.         {
  33.             if (btnStartStop.getText().equals("Start"))
  34.             {
  35.                 btnStartStop.setText("Stop");
  36.                 timer.start();
  37.             }
  38.             else 
  39.             {
  40.                 btnStartStop.setText("Start");
  41.                 timer.stop();
  42.             }
  43.         };
  44.         btnStartStop.addActionListener(al);
  45.         pnl.add(btnStartStop);
  46.         setContentPane(pnl);
  47.         setSize(300, 80);
  48.         setVisible(true);
  49.     }
  51.     public static void main(String[] args)
  52.     {
  53.         EventQueue.invokeLater(() -> new Counter("Counter"));
  54.     }
  55. }

清单B-5中main()方法创建一个由标签和开始、停止按钮构成的GUI。这个标签展示count变量的当前值而按钮上的文字则在开始和停止之间切换。当按钮显示开始时，点击会触发定时器启动；而按钮显示停止时，点击会导致定时器停止。定时器的动作监听器递增count变量并将值显示到标签上。加在count变量之后的空格字符串会把表达式转换成一个字符串从而保证不会截断最右边的像素。

照下面编译清单B-5：

  1. javac Counter.java

运行程序：

  1. java Counter

图B-2展示了结果GUI。

[图]
图B-2. 面板中的组件水平居中

基于定时器的幻灯片展示

幻灯片展示就是在投影仪屏幕之上一组静态图片的演示，通常会以预先安排好的顺序播放。每张图片一般都会至少显示几秒而后被下一张图片替换。

幻灯片的展示会涉及一个投影仪、一个屏幕和一组幻灯片。投影仪含有将被投影的幻灯片，屏幕用于展示被投影的幻灯片，而幻灯片则包含一张图片和其它属性（例如一个文本的标题）。

我创建了一个名为SlideShow的Java应用程序，它可以让你投影任意的幻灯片。清单B-6是它的源码。

清单B-6 描述一个基于定时器的幻灯片展示

  1. import javax.imageio.ImageIO;
  2. import javax.swing.*;
  3. import java.awt.*;
  4. import java.awt.event.ActionListener;
  5. import java.awt.event.WindowAdapter;
  6. import java.awt.event.WindowEvent;
  7. import java.awt.image.BufferedImage;
  8. import java.io.BufferedReader;
  9. import java.io.File;
  10. import java.io.FileReader;
  11. import java.io.IOException;
  12. import java.util.ArrayList;
  13. import java.util.List;
  15. class Projector {
  16.     private volatile List<Slide> slides;
  17.     private Screen s;
  18.     private Timer t;
  19.     private volatile int slideIndexC, slideIndexN;
  20.     private volatile float weight;
  22.     Projector(List<Slide> slides, Screen s) {
  23.         this.slides = slides;
  24.         this.s = s;
  25.         t = new Timer(1500, null);
  26.         t.setDelay(3000);
  27.         slideIndexC = 0;
  28.         slideIndexN = 1;
  29.     }
  31.     void start() {
  32.         s.drawImage(Slide.blend(slides.get(0), null, 1.0f));
  33.         ActionListener al = (ae) ->
  34.         {
  35.             weight = 1.0f;
  36.             Timer t2 = new Timer(0, null);
  37.             t2.setDelay(10);
  38.             ActionListener al2 = (ae2) ->
  39.             {
  40.                 Slide slideC = slides.get(slideIndexC);
  41.                 Slide slideN = slides.get(slideIndexN);
  42.                 BufferedImage bi = Slide.blend(slideC, slideN, weight);
  43.                 s.drawImage(bi);
  44.                 weight -= 0.01f;
  45.                 if (weight <= 0.0f) {
  46.                     t2.stop();
  47.                     slideIndexC = slideIndexN;
  48.                     slideIndexN = (slideIndexN + 1) % slides.size();
  49.                 }
  50.             };
  51.             t2.addActionListener(al2);
  52.             t2.start();
  53.         };
  54.         t.addActionListener(al);
  55.         t.start();
  56.     }
  58.     void stop() {
  59.         t.stop();
  60.     }
  61. }
  63. class Screen extends JComponent {
  64.     private Dimension d;
  65.     private BufferedImage bi;
  66.     private String text;
  68.     Screen(int width, int height) {
  69.         d = new Dimension(width, height);
  70.     }
  72.     void drawImage(BufferedImage bi) {
  73.         this.bi = bi;
  74.         repaint();
  75.     }
  77.     @Override
  78.     public Dimension getPreferredSize() {
  79.         return d;
  80.     }
  82.     @Override
  83.     public void paint(Graphics g) {
  84.         int w = getWidth();
  85.         int h = getHeight();
  86.         g.drawImage(bi, Slide.WIDTH <= w ? (w - Slide.WIDTH) / 2 : 0,
  87.                 Slide.HEIGHT <= h ? (h - Slide.HEIGHT) / 2 : 0, null);
  88.     }
  89. }
  91. class Slide {
  92.     static int WIDTH, HEIGHT;
  93.     private static int TEXTBOX_WIDTH, TEXTBOX_HEIGHT, TEXTBOX_X, TEXTBOX_Y;
  94.     private BufferedImage bi;
  95.     private String text;
  96.     private static Font font;
  98.     private Slide(BufferedImage bi, String text) {
  99.         this.bi = bi;
  100.         this.text = text;
  101.         font = new Font("Arial", Font.BOLD, 20);
  102.     }
  104.     static BufferedImage blend(Slide slide1, Slide slide2, float weight) {
  105.         BufferedImage bi1 = slide1.getBufferedImage();
  106.         BufferedImage bi2 = (slide2 != null)
  107.                 ? slide2.getBufferedImage()
  108.                 : new BufferedImage(Slide.WIDTH, Slide.HEIGHT,
  109.                 BufferedImage.TYPE_INT_RGB);
  110.         BufferedImage bi3 = new BufferedImage(Slide.WIDTH, Slide.HEIGHT,
  111.                 BufferedImage.TYPE_INT_RGB);
  112.         Graphics2D g2d = bi3.createGraphics();
  113.         g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
  114.                 weight));
  115.         g2d.drawImage(bi1, 0, 0, null);
  116.         g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
  117.                 1.0f - weight));
  118.         g2d.drawImage(bi2, 0, 0, null);
  119.         g2d.setColor(Color.BLACK);
  120.         g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
  121.                 RenderingHints.VALUE_ANTIALIAS_ON);
  122.         g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
  123.                 0.5f));
  125.         g2d.fillRect(TEXTBOX_X, TEXTBOX_Y, TEXTBOX_WIDTH, TEXTBOX_HEIGHT);
  126.         g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
  127.                 weight));
  128.         g2d.setColor(Color.WHITE);
  129.         g2d.setFont(font);
  130.         FontMetrics fm = g2d.getFontMetrics();
  131.         g2d.drawString(slide1.getText(), TEXTBOX_X + (TEXTBOX_WIDTH -
  132.                         fm.stringWidth(slide1.getText())) / 2,
  133.                 TEXTBOX_Y + TEXTBOX_HEIGHT / 2 + fm.getHeight() / 4);
  134.         g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
  135.                 1.0f - weight));
  136.         if (slide2 != null)
  137.             g2d.drawString(slide2.getText(), TEXTBOX_X + (TEXTBOX_WIDTH -
  138.                     fm.stringWidth(slide2.getText())) / 2, TEXTBOX_Y +
  139.                     TEXTBOX_HEIGHT / 2 + fm.getHeight() / 4);
  141.         g2d.dispose();
  142.         return bi3;
  143.     }
  146.     BufferedImage getBufferedImage() {
  147.         return bi;
  148.     }
  150.     String getText() {
  151.         return text;
  152.     }
  154.     static List<Slide> loadSlides(String imagesPath) throws IOException {
  155.         File imageFilesPath = new File(imagesPath);
  156.         if (!imageFilesPath.isDirectory())
  157.             throw new IOException(imagesPath + " identifies a file");
  158.         List<Slide> slides = new ArrayList<>();
  159.         try (FileReader fr = new FileReader(imagesPath + "/index");
  160.              BufferedReader br = new BufferedReader(fr)) {
  161.             String line;
  162.             while ((line = br.readLine()) != null) {
  163.                 String[] parts = line.split(",");
  164.                 File file = new File(imageFilesPath + "/" + parts[0] + ".jpg");
  165.                 System.out.println(file);
  166.                 BufferedImage bi = ImageIO.read(file);
  167.                 if (WIDTH == 0) {
  168.                     WIDTH = bi.getWidth();
  171.                     HEIGHT = bi.getHeight();
  172.                     TEXTBOX_WIDTH = WIDTH / 2 + 10;
  173.                     TEXTBOX_HEIGHT = HEIGHT / 10;
  174.                     TEXTBOX_Y = HEIGHT - TEXTBOX_HEIGHT - 5;
  175.                     TEXTBOX_X = (WIDTH - TEXTBOX_WIDTH) / 2;
  176.                 }
  177.                 slides.add(new Slide(bi, parts[1]));
  178.             }
  179.         }
  180.         if (slides.size() < 2)
  181.             throw new IOException("at least one image must be loaded");
  182.         return slides;
  183.     }
  184. }
  186. public class SlideShow {
  187.     public static void main(String[] args) throws IOException {
  188.         if (args.length != 1) {
  189.             System.err.println("usage: java SlideShow ssdir");
  190.             return;
  191.         }
  192.         List<Slide> slides = Slide.loadSlides(args[0]);
  193.         final Screen screen = new Screen(Slide.WIDTH, Slide.HEIGHT);
  194.         final Projector p = new Projector(slides, screen);
  195.         Runnable r = () ->
  196.         {
  197.             final JFrame f = new JFrame("Slide Show");
  198.             WindowAdapter wa = new WindowAdapter() {
  199.                 @Override
  200.                 public void windowClosing(WindowEvent we) {
  201.                     p.stop();
  202.                     f.dispose();
  203.                 }
  204.             };
  205.             f.addWindowListener(wa);
  206.             f.setContentPane(screen);
  207.             f.pack();
  208.             f.setVisible(true);
  209.             p.start();
  210.         };
  211.         EventQueue.invokeLater(r);
  212.     }
  213. }

清单B-6基于类Projector、Screen、Slide以及SlideShow构建了一个幻灯片演示。Projector声明了几个private属性、一个用一组（java.util.List）Slide对象和单个Screen对象初始化投影仪对象的Projector(List slides, Screen s)构造函数、一个用于启动投影仪的void start()方法和一个停止投影仪的stop()方法。

Screen继承自javax.swing.JComponent，这使得Screen变成了一个特殊类型的Swing组件。它声明了几个private属性、一个接收width和height参数来初始化该组件的Screen(int width, int height)构造函数以及一个drawImage(BufferedImage bi)方法用于在屏幕的表面绘制传递进来的缓冲图片。这个类也重写了Dimension getPreferredSize()和void paint(Graphics g)方法，它们分别用于返回该组件的偏好大小和绘制图片。

Slide声明了多个常量、几个私有属性，一个用于初始化Slide对象的Slide(BufferedImage bi, String text)的私有构造函数、两个用于返回幻灯片的缓冲图片和文字的getter方法BufferedImage getBufferedImage()和String getText()，一个用于混合一对缓冲图片来实现幻灯片之间的过渡效果的类方法BufferedImage blend(Slide slide1, Slide slide2, float weight)以及用于加载所有幻灯片的图片的方法List loadSlides(String imagesPath)。

blend()方法抽取了与其slide参数相关联的缓冲图片，并且用weight值（必须落在0.0到1.0这个区间内）决定的混合度把这些图片混合到一起。传递给weight的值越高，slide1的图片就会更多地融入返回的缓冲图片中。混合图片之后，blend()方法在已混合的图片之上再混入一对文字字符串。类java.awt.AlphaComposite参与到每次混合操作中。

我已经设计blend()方法处理了slide2是null的特殊场景。这会发生在Projector的start()方法开始的时候，这时它执行了s.drawImage(Slide.blend(slides.get(0), null, 1.0f));方法来显示第一张幻灯片，并且不会有过渡。

loadSlides()方法查找字符串参数所指定目录底下名为index的文本文件，然后创建一组被文本文件排序的Slides——你可以选择一种不同于该目录下文件所确定的图片顺序来展示幻灯片。文本文件中的每一行都被组织成一个文件名后跟一个分号，再跟一个文字的描述（例如：earth, Terran System）。在指定文件名字的时候，你不必指定文件的扩展名，loadSlides()方法只能识别JPEG文件。

SlideShow声明了一个main()方法用于驱动这个应用程序。这个方法首先验证一个单一的命令行参数确定幻灯片的目录（目录中包含了index和JPEG文件）已经就绪。之后它调用了loadSlides()方法从这个目录中加载index和所有幻灯片图片。当loadSlides()方法无法加载图片或者图片的数量小于2时，它抛出java.io.IOException。毕竟，你如何用少于2张的图片来做幻灯片演示呢？

main()方法接下来创建一个Screen组件对象用于展示幻灯片图片。它把每个slide（事实上，是每个幻灯片图片的宽度和高度）的宽度和高度传递给Screen的构造函数，保证了屏幕能够充分展示这些幻灯片。（尽管我在loadSlides()方法中没做强制，但是所有的幻灯片图片必须用于同样的宽度和高度。）

剩下唯一需要创建的主要模型对象就是这个投影仪，main()方法通过把一组从loadSlides()方法中返回的Slide对象和前面创建的Screen对象传递到Projector的构造函数中完成了这一任务。

main()方法最后的任务就是触发GUI能在EDT上构造出来。这个线程把内容面板设置到Screen对象中并且调用了Projector的void start()方法开始播放幻灯片。同时，它也创建了一个窗口监听器用在用户试图关闭窗口时调用Projector的void stop()方法。之后窗口就会被销毁掉。

Projector使用了一对Timer对象来管理幻灯片演示。主定时器负责推进投影仪进入下一张幻灯片，而次定时器对象（在每次主定时器触发一个动作事件被创建出来）则负责过渡当前播放的幻灯片到下一张（借助blend()方法）。

每个定时器实例都运行在EDT之上。次定时器在运行时主定时器不可以执行定时器任务。如果打破这个规则，这个幻灯片演示就会发生故障。我在主定时器任务相继执行之间选取了3000毫秒，而次定时器任务相继执行之间选取了10毫秒，这样运行100次，大约需要1000毫秒。当次定时器结束了，它会自动停止。

照下面编译清单B-6：

  1. javac SlideShow.java

假如是Windows操作系统，运行结果应用程序如下：

  1. java SlideShow ..\ss

ss标志这是一个太阳系的幻灯片演示（包含在本书的代码当中），放置于当前目录的父级目录下。

图B-3 展示结果GUI
[图]

图B-3. SlideShow靠近slide底部的文字水平居中

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注