用Robot实现自动截取当前窗体

最近公司在项目中提了个需求想自动截图窗体,然后发送给服务端.我就看了下抓屏的例子,在此基础上进行了修改达到了项目中所要求的.

思路就是获取当前窗体的坐标,然后进行截图,抓屏是通过鼠标的按下和释放,来获取开始坐标和结束坐标.

首先获取窗体的位置,项目用的SWT.

	/**
				 * 获取窗体的位置
				 */
				 Rectangle rectangle=shell.getBounds();
				 
				 java.awt.Rectangle rct = new java.awt.Rectangle(rectangle.x,rectangle.y, rectangle.width,
						  rectangle.height);
				 
				 new AutoScreeFrame(robot,screenSize,rct);

其次就是,AutoScreeFrame 这个自动截屏类

package com.cayden.test;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.Toolkit;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;
/**
 * 自动截图
 * @author cuiran
 *
 */
public class AutoScreeFrame {
	  private static Settings settings = Settings.getInstance();
    private Point start; // 左上角点
    private Point end; // 右下角点
    JFrame topFrame = new JFrame(); // 用来将整个活动屏幕覆盖掉，以实现对区域截图
    JPanel imagePanel; // 区域截屏时，用来显示整个屏幕的截图
    final BufferedImage im;
    Rectangle rect;
    
    public AutoScreeFrame(final Robot robot, Dimension size,Rectangle rectangle) {
        
        this.rect=rectangle;
        start = new Point(rect.x,rect.y);
        topFrame.setBounds(0, 0, size.width, size.height);

        Rectangle rct = new Rectangle(0, 0, (int) size.getWidth(), (int) size.getHeight());

        im = robot.createScreenCapture(rct);
        
        imagePanel = new JPanel() {
            @Override
            public void paint(Graphics g) {
                // TODO Auto-generated method stub
                super.paint(g);
                g.drawImage(im, 0, 0, im.getWidth(), im.getHeight(), null);
            }
        };

        imagePanel.setSize(size);
        topFrame.add(imagePanel);
        // 去掉Frame的装饰，变成一个没有边框的面板，实现区域抓屏的关键
        topFrame.setUndecorated(true);
        topFrame.setVisible(true);

     
        
        end = new Point((rect.x+rect.width),(rect.y+rect.height));
        
        if (invaildRectangle()) {
            topFrame.dispose();
            return;
        }
        Rectangle rct1 = getDraggedRectangle();
        outputImage2SavePlace(im, rct1);
        start = null;
        end = null;
        topFrame.dispose();
    }
    protected  void setImage2Clipboard(final BufferedImage image, final Rectangle rct) {
        Transferable trans = new Transferable() {

            public DataFlavor[] getTransferDataFlavors() {
                return new DataFlavor[]{DataFlavor.imageFlavor};
            }

            public boolean isDataFlavorSupported(DataFlavor flavor) {
                return DataFlavor.imageFlavor.equals(flavor);
            }

            public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
                if (isDataFlavorSupported(flavor)) {
                    return image.getSubimage(rct.x, rct.y, rct.width, rct.height);
                }
                throw new UnsupportedFlavorException(flavor);
            }
        };
        Toolkit.getDefaultToolkit().getSystemClipboard().setContents(trans, null);
    }

    public  void writeImageToFile(BufferedImage im, Rectangle rct) {
        try {
            im = im.getSubimage(rct.x, rct.y, rct.width, rct.height);
            String fileName = settings.getOutputFileName();
            ImageIO.write(im, settings.getImageFormatString(), new File(fileName));
        } catch (IOException e1) {
           
            e1.printStackTrace();
        }
    }
    public  void outputImage2SavePlace(BufferedImage im, Rectangle rct) {
        if (Settings.getInstance().getSavePlace() == Settings.FILE) {
            writeImageToFile(im, rct);
        } else {
            setImage2Clipboard(im, rct);
        }
    }
    private Rectangle getDraggedRectangle() {
        int x = start.x <= end.x ? start.x : end.x;
        int y = start.y <= end.y ? start.y : end.y;
        Rectangle rct = new Rectangle(x, y, Math.abs(end.x - start.x),
                Math.abs(end.y - start.y));
        return rct;
    }

    private boolean invaildRectangle() {
        return Math.abs(end.x - start.x) <= 0 || Math.abs(end.y - start.y) <= 0;
    }
}

大致就是这样.结果就是根据坐标来获取当前窗体的的画面.

需要源代码的在评论处留下您的邮箱.