Java 无边框打印屏幕

我想在没有JFrame本身的情况下，对JFrame后面的内容进行打印。我尝试的方法是关闭窗口，等待一段时间使其完全关闭，然后取下打印屏幕，然后再次打开。当前的方法不适合我的需要，因为我需要更频繁地执行此操作，并且等待窗口关闭的时间太长。还有，我不想因此而关上窗户

这是我目前的代码：

public class Offscreen {

    private static BufferedImage img;

    public static void main(String[] main)
                throws AWTException, InterruptedException {
        JFrame frame = new JFrame() {
            @Override
            public void paint(Graphics g) {
                if (img != null)
                    // draw print screen
                    g.drawImage(img, 0, 0, null);
            }
        };
        frame.setSize(500, 500);
        frame.setLocation(700, 0);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);

        frame.setVisible(false);

        Thread.sleep(200);

        // take the picture
        Robot r = new Robot();
        img = r.createScreenCapture(frame.getBounds());

        // show the source again
        frame.setVisible(true);
        // print on destiny
        frame.repaint();
    }
}

“假设”您只想捕获活动帧后面的区域（如您所说，没有帧），然后类似

import java.awt.AWTException;
import java.awt.AlphaComposite;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.awt.image.BufferedImage;
import java.lang.reflect.InvocationTargetException;
import java.util.concurrent.ExecutionException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.SwingWorker;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class PrintScreen01 {

    public static void main(String[] args) {
        new PrintScreen01();
    }

    private Timer timer;

    public PrintScreen01() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException ex) {
                } catch (InstantiationException ex) {
                } catch (IllegalAccessException ex) {
                } catch (UnsupportedLookAndFeelException ex) {
                }

                final PrintPane printPane = new PrintPane();

                final JFrame frame = new JFrame("Test");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setLayout(new BorderLayout());
                frame.add(printPane);
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.addComponentListener(new ComponentAdapter() {

                    @Override
                    public void componentMoved(ComponentEvent e) {
                        timer.restart();
                    }

                    @Override
                    public void componentResized(ComponentEvent e) {
                        timer.restart();
                    }

                });
                timer = new Timer(250, new ActionListener() {
                    @Override
                    public void actionPerformed(ActionEvent e) {
                        if (frame.isVisible()) {
                            takeSnapShot(frame, printPane);
                        }
                    }
                });
                timer.setRepeats(false);
                frame.setVisible(true);
//                takeSnapShot(frame, printPane);
            }
        });
    }

    public void takeSnapShot(JFrame frame, PrintPane pane) {

        Rectangle bounds = new Rectangle(pane.getLocationOnScreen(), pane.getSize());
        frame.setVisible(false);
        new SnapShotWorker(frame, pane, bounds).execute();

    }

    public class SnapShotWorker extends SwingWorker<BufferedImage, BufferedImage> {

        private JFrame frame;
        private PrintPane pane;
        private Rectangle captureBounds;

        public SnapShotWorker(JFrame frame, PrintPane pane, Rectangle bounds) {
            this.frame = frame;
            this.pane = pane;
            captureBounds = bounds;
        }

        @Override
        protected BufferedImage doInBackground() throws Exception {

            Thread.sleep(125);

            BufferedImage snapShot = null;
            try {
                Robot bot = new Robot();
                snapShot = bot.createScreenCapture(captureBounds);
            } catch (AWTException ex) {
                ex.printStackTrace();
            }
            Thread.sleep(125);
            return snapShot;
        }

        @Override
        protected void done() {
            try {
                BufferedImage snapShot = get();
                pane.setSnapShot(snapShot);
                frame.setVisible(true);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            } catch (ExecutionException ex) {
                ex.printStackTrace();
            }
        }



    }

    public class PrintPane extends JPanel {

        private BufferedImage background;

        public PrintPane() {
        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(200, 200);
        }

        public void setSnapShot(BufferedImage img) {
            background = img;
            repaint();
        }

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            if (background != null) {
                Graphics2D g2d = (Graphics2D) g.create();
                g2d.setComposite(AlphaComposite.SrcOver.derive(0.5f));
                g2d.drawImage(background, 0, 0, this);
                g2d.dispose();
            }
        }

    }

}

import java.awt.AWTException；
导入java.awt.AlphaComposite；
导入java.awt.BorderLayout；
导入java.awt.Dimension；
导入java.awt.EventQueue；
导入java.awt.Graphics；
导入java.awt.Graphics2D；
导入java.awt.Rectangle；
导入java.awt.Robot；
导入java.awt.event.ActionEvent；
导入java.awt.event.ActionListener；
导入java.awt.event.ComponentAdapter；
导入java.awt.event.ComponentEvent；
导入java.awt.image.buffereImage；
导入java.lang.reflect.InvocationTargetException；
导入java.util.concurrent.ExecutionException；
导入java.util.logging.Level；
导入java.util.logging.Logger；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
导入javax.swing.SwingUtilities；
导入javax.swing.SwingWorker；
导入javax.swing.Timer；
导入javax.swing.UIManager；
导入javax.swing.UnsupportedLookAndFeelException；
公共类PrintScreen01{
公共静态void main（字符串[]args）{
新的PrintScreen01（）；
}
私人定时器；
公共打印屏幕01（）{
invokeLater（新的Runnable（）{
@凌驾
公开募捐{
试一试{
UIManager.setLookAndFeel（UIManager.getSystemLookAndFeelClassName（））；
}捕获（ClassNotFoundException ex）{
}catch（实例化异常）{
}捕获（非法访问例外）{
}捕获（无支持的LookandFeelexception ex）{
}
最终打印窗格打印窗格=新打印窗格（）；
最终JFrame=新JFrame（“测试”）；
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
frame.setLayout（新的BorderLayout（））；
frame.add（打印窗格）；
frame.pack（）；
frame.setLocationRelativeTo（空）；
frame.addComponentListener（新的ComponentAdapter（）{
@凌驾
公共无效组件已移动（组件事件e）{
timer.restart（）；
}
@凌驾
公共无效组件已恢复（组件事件e）{
timer.restart（）；
}
});
计时器=新计时器（250，新ActionListener（）{
@凌驾
已执行的公共无效操作（操作事件e）{
if（frame.isVisible（））{
拍摄快照（框架、打印窗格）；
}
}
});
timer.setRepeats（假）；
frame.setVisible（true）；
//拍摄快照（框架、打印窗格）；
}
});
}
公共void快照（JFrame框架、打印窗格）{
矩形边界=新矩形（pane.getLocationOnScreen（），pane.getSize（））；
frame.setVisible（假）；
新建SnapShotWorker（框架、窗格、边界）.execute（）；
}
公共类SnapShotWorker扩展了SwingWorker{
私有JFrame；
私人印刷版；
私有矩形捕获边界；
公共SnapShotWorker（JFrame框架、PrintPane窗格、矩形边框）{
this.frame=frame；
this.pane=窗格；
captureBounds=边界；
}
@凌驾
受保护的BuffereImage doInBackground（）引发异常{
睡眠（125）；
BuffereImage快照=空；
试一试{
机器人机器人=新机器人（）；
快照=bot.createScreenCapture（captureBounds）；
}捕获（AWEX）{
例如printStackTrace（）；
}
睡眠（125）；
返回快照；
}
@凌驾
受保护的void done（）{
试一试{
BuffereImage快照=获取（）；
窗格。设置快照（快照）；
frame.setVisible（true）；
}捕获（中断异常例外）{
例如printStackTrace（）；
}捕获（ExecutionException ex）{
例如printStackTrace（）；
}
}
}
公共类PrintPane扩展了JPanel{
私有缓冲图像背景；
公共打印窗格（）{
}
@凌驾
公共维度getPreferredSize（）{
返回新维度（200200）；
}
公共无效设置快照（BuffereImage img）{
背景=img；
重新油漆（）；
}
@凌驾
受保护组件（图形g）{
超级组件（g）；
如果（背景！=null）{
Graphics2D g2d=（Graphics2D）g.create（）；
g2d.setComposite（AlphaComposite.SrcOver.derive（0.5f））；
g2d.drawImage（背景，0，0，this）；
g2d.dispose（）；
}
}
}
}

可能会有帮助

现在，我对机器人的计时有一些问题，似乎部分操作是以某种方式线程化的，这意味着除非你让帧的计时在不可见和可见之间“刚好”改变，否则你实际上会重新捕获帧…令人讨厌

为了尝试解决这个问题，减少捕获屏幕的次数，我使用了

javax.swing.Timer

（减少捕获尝试）