java – 更有效地为JList加载图像,可能是使用SwingWorker
作者：互联网
我有一个问题,我希望SwingWorker可以帮助我,但我不太确定如何将它集成到我的程序中.
问题：
在CardLayout中,我在Card1上有一个打开Card2的按钮.
Card2有一个带有自定义渲染器(扩展JLabel)的JList,它将平均显示1到6个图像：
> PNG
>大约500kb
>通过更换卡片,通过imageIO加载
渲染器应用重度操作(如图像缩放或模糊),然后将图像设置为JLabel图标.
如果必须渲染大约6张图像,这几乎可能需要一秒钟,这种情况不会经常发生,但即使偶尔会出现无反应的瞬间感觉很糟糕.
现在我认为SwingWorker可能会对此有所帮助,但我对如何整合它感到困惑.
假设我们有这段代码片段
import javax.swing.*;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
public class Example {
private JPanel mainPanel = new JPanel();
private JList<Product> list = new JList();
private JScrollPane scroll = new JScrollPane();
private Map<String, Color> colorMap = new HashMap<>();
public Example() {
colorMap.put("red", Color.red);
colorMap.put("blue", Color.blue);
colorMap.put("cyan", Color.cyan);
colorMap.put("green", Color.green);
colorMap.put("yellow", Color.yellow);
mainPanel.setBackground(new Color(129, 133, 142));
scroll.setViewportView(list);
scroll.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
scroll.setPreferredSize(new Dimension(80,200));
list.setCellRenderer(new CustomRenderer());
DefaultListModel model = new DefaultListModel();
model.addElement(new Product("red"));
model.addElement(new Product("yellow"));
model.addElement(new Product("blue"));
model.addElement(new Product("red"));
model.addElement(new Product("cyan"));
list.setModel(model);
mainPanel.add(scroll);
}
public static void main(String[] args) throws IOException {
EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
JFrame frame = new JFrame("WorkerTest");
frame.setContentPane(new Example().mainPanel);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLocation(300, 300);
frame.setMinimumSize(new Dimension(160, 255));
frame.setVisible(true);
}
});
}
class CustomRenderer extends JLabel implements ListCellRenderer<Product> {
private Product product;
public CustomRenderer() {
setOpaque(false);
}
@Override
public Component getListCellRendererComponent(JList<? extends Product> list, Product product, int index, boolean isSelected, boolean cellHasFocus) {
this.product = product;
/**
* in the actual code image is png with alpha channel respectively named to the productID of the JList object
*
* String id = product.getId();
* image = ImageIO.read(getClass().getResource("../../resources/images/" + id + ".png"));
*/
BufferedImage image1 = new BufferedImage(80, 50, BufferedImage.TYPE_INT_RGB);
BufferedImage image2 = new BufferedImage( 80, 75, BufferedImage.TYPE_INT_RGB);
Graphics g = image2.getGraphics();
/**
* this is only an example, in the actual code I might also apply gaussian blurs or rescale several time
*/
g.drawImage(image1,0,0,null);
setIcon(new ImageIcon(image2));
return this;
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.setColor(colorMap.get(product.getColor()));
g.fillRect(0,0,80,75);
}
}
class Product {
String productID;
String color;
public Product(String color) {
this.color = color;
}
public String getColor() {
return color;
}
public String getProductID() {
return productID;
}
}
}
我是否必须从每个getListCellRendererComponent调用调用SwingWorker
接管图像操作？
SwingWorker甚至是解决这个问题的合适工具吗？
任何有关如何使我的GUI更快部分的帮助将非常感激.
编辑：
Hovercraft Full Of Eels提到预加载图像可能会有所帮助,而且从渲染器加载图像基本上是错误的.
这引出了另一个问题：
我有一个列表(让我们称之为list1)与大约3000个对象,每个对象有一个8kb jpg缩略图,它通过对象ID加载(也在渲染过程中)
该列表同时显示这些缩略图中的大约6到12个(由于List的维度)
当用户选择一个对象时,他可以按一个按钮从原始问题中提到的Cardlayout中显示Card2,并使用该对象列出(list2)
以及非缩略图视图中的所有相关对象(500kb png重图像操作).现在我认为预加载对象的非缩略图图像以及在第一个列表中选择的关系是可行的,这将是大约1-6个图像.如果我正确理解了Hovercraft Full Of Eels的说法,那么我可以在从list1中选择一个Object后使用SwingWorker来加载这些图像.
但是,如果来自list1的大约3000张图像,该程序似乎没有放慢速度或者没有响应,因为它们的尺寸相当小,并且缩略图上没有繁重的操作,但它们仍然是从list1的渲染器加载的.预加载数千个缩略图是否有意义？
顺便说一句.如果不希望这样的问题编辑,并且是否应该成为自己的问题,请随时告诉我.
解决方法:
一种方法可能如下：
每当请求某个元素(Product)的单元格渲染器组件时,都会检查是否已加载匹配的图像.如果没有,您启动一个Swing工作器,负责在后台加载和处理图像.工作完成后,将图像放入缓存中以供以后查找.在此期间,您让渲染器只是说“正在加载……”或其他东西.
这里有一个非常快速的实现：
作为MCVE：
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.Collections;
import java.util.Map;
import java.util.Objects;
import java.util.Random;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import javax.swing.DefaultListModel;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.ListCellRenderer;
import javax.swing.SwingWorker;
public class LazyImageLoadingCellRendererTest
{
private JPanel mainPanel = new JPanel();
private JList<Product> list = new JList<Product>();
private JScrollPane scroll = new JScrollPane();
public LazyImageLoadingCellRendererTest()
{
mainPanel.setBackground(new Color(129, 133, 142));
scroll.setViewportView(list);
scroll.setHorizontalScrollBarPolicy(
JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
scroll.setPreferredSize(new Dimension(80, 200));
list.setCellRenderer(new LazyImageLoadingCellRenderer<Product>(list,
LazyImageLoadingCellRendererTest::loadAndProcessImage));
DefaultListModel<Product> model = new DefaultListModel<Product>();
for (int i=0; i<1000; i++)
{
model.addElement(new Product("id" + i));
}
list.setModel(model);
mainPanel.add(scroll);
}
public static void main(String[] args) throws IOException
{
EventQueue.invokeLater(new Runnable()
{
@Override
public void run()
{
JFrame frame = new JFrame("WorkerTest");
frame.setContentPane(
new LazyImageLoadingCellRendererTest().mainPanel);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLocation(300, 300);
frame.setMinimumSize(new Dimension(160, 255));
frame.setVisible(true);
}
});
}
private static final Random random = new Random(0);
private static BufferedImage loadAndProcessImage(Product product)
{
String id = product.getProductID();
int w = 100;
int h = 20;
BufferedImage image =
new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
Graphics2D g = image.createGraphics();
g.setColor(Color.GREEN);
g.fillRect(0, 0, w, h);
g.setColor(Color.BLACK);
g.drawString(id, 10, 16);
g.dispose();
long delay = 500 + random.nextInt(3000);
try
{
System.out.println("Load time of " + delay + " ms for " + id);
Thread.sleep(delay);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
return image;
}
class Product
{
String productID;
public Product(String productID)
{
this.productID = productID;
}
public String getProductID()
{
return productID;
}
}
}
class LazyImageLoadingCellRenderer<T> extends JLabel
implements ListCellRenderer<T>
{
private final JList<?> owner;
private final Function<? super T, ? extends BufferedImage> imageLookup;
private final Set<T> pendingImages;
private final Map<T, BufferedImage> loadedImages;
public LazyImageLoadingCellRenderer(JList<?> owner,
Function<? super T, ? extends BufferedImage> imageLookup)
{
this.owner = Objects.requireNonNull(
owner, "The owner may not be null");
this.imageLookup = Objects.requireNonNull(imageLookup,
"The imageLookup may not be null");
this.loadedImages = new ConcurrentHashMap<T, BufferedImage>();
this.pendingImages =
Collections.newSetFromMap(new ConcurrentHashMap<T, Boolean>());
setOpaque(false);
}
class ImageLoadingWorker extends SwingWorker<BufferedImage, Void>
{
private final T element;
ImageLoadingWorker(T element)
{
this.element = element;
pendingImages.add(element);
}
@Override
protected BufferedImage doInBackground() throws Exception
{
try
{
BufferedImage image = imageLookup.apply(element);
loadedImages.put(element, image);
pendingImages.remove(element);
return image;
}
catch (Exception e)
{
e.printStackTrace();
return null;
}
}
@Override
protected void done()
{
owner.repaint();
}
}
@Override
public Component getListCellRendererComponent(JList<? extends T> list,
T value, int index, boolean isSelected, boolean cellHasFocus)
{
BufferedImage image = loadedImages.get(value);
if (image == null)
{
if (!pendingImages.contains(value))
{
//System.out.println("Execute for " + value);
ImageLoadingWorker worker = new ImageLoadingWorker(value);
worker.execute();
}
setText("Loading...");
setIcon(null);
}
else
{
setText(null);
setIcon(new ImageIcon(image));
}
return this;
}
}
注意：
这只是一个显示一般方法的简单示例.当然,这可以通过多种方式得到改善.虽然实际的加载过程已经被拉入一个函数(因此它一般适用于任何类型的图像,无论它来自何处),但一个主要的警告是：它将尝试加载所有图像.一个很好的扩展是在这里添加一些智能,并确保它只加载单元格当前可见的图像.例如,如果您有一个包含1000个元素的列表,并且想要查看最后10个元素,那么您不必等待加载990个元素.最后的元素应该更高并且先加载.但是,为此,可能需要稍大的基础结构(主要是：自己的任务队列以及与列表及其滚动窗格的一些更强连接). (有一天我可能会解决这个问题,因为它可能是一个很好的有趣的东西,但在那之前,上面的例子可能会这样做……)
标签：swingworker,java,swing 来源： https://codeday.me/bug/20190727/1549456.html