Java调用打印机打印图片和文本的多种方法_Java

在java中调用打印机打印文本和图片有多种方法，以下是几种常用的实现方式：

一、使用java内置的打印api

1.基本打印框架

import javax.print.*;
import javax.print.attribute.*;
import javax.print.attribute.standard.*;
import java.awt.*;
import java.awt.print.*;
import java.io.*;
import javax.imageio.imageio;

public class javaprinter {
    
    // 打印文本
    public static void printtext(string text) {
        printerjob job = printerjob.getprinterjob();
        
        // 设置打印内容
        job.setprintable(new printable() {
            @override
            public int print(graphics g, pageformat pf, int pageindex) {
                if (pageindex > 0) {
                    return printable.no_such_page;
                }
                
                graphics2d g2d = (graphics2d) g;
                g2d.translate(pf.getimageablex(), pf.getimageabley());
                
                // 设置字体
                font font = new font("宋体", font.plain, 12);
                g2d.setfont(font);
                
                // 绘制文本
                g2d.drawstring(text, 100, 100);
                
                return printable.page_exists;
            }
        });
        
        try {
            // 显示打印对话框
            if (job.printdialog()) {
                job.print();
            }
        } catch (printerexception e) {
            e.printstacktrace();
        }
    }
}

2.完整打印类（支持文本和图片）

import javax.print.*;
import javax.print.attribute.*;
import javax.print.attribute.standard.*;
import java.awt.*;
import java.awt.print.*;
import java.awt.image.*;
import javax.imageio.*;
import java.io.*;

public class documentprinter implements printable {
    
    private string text;
    private bufferedimage image;
    private boolean hasimage;
    
    public documentprinter(string text) {
        this.text = text;
        this.hasimage = false;
    }
    
    public documentprinter(string text, bufferedimage image) {
        this.text = text;
        this.image = image;
        this.hasimage = true;
    }
    
    public void printdocument() {
        printerjob printerjob = printerjob.getprinterjob();
        printerjob.setprintable(this);
        
        // 设置打印属性
        pageformat pageformat = printerjob.defaultpage();
        
        // 自定义页面设置
        paper paper = new paper();
        paper.setsize(595, 842); // a4 size in points (1/72 inch)
        paper.setimageablearea(72, 72, 451, 698); // 1 inch margins
        pageformat.setpaper(paper);
        
        // 显示打印对话框
        if (printerjob.printdialog()) {
            try {
                printerjob.print();
            } catch (printerexception e) {
                system.err.println("打印失败: " + e.getmessage());
            }
        }
    }
    
    @override
    public int print(graphics graphics, pageformat pageformat, int pageindex) 
            throws printerexception {
        
        if (pageindex > 0) {
            return no_such_page;
        }
        
        graphics2d g2d = (graphics2d) graphics;
        
        // 设置高质量渲染
        g2d.setrenderinghint(renderinghints.key_antialiasing, 
                            renderinghints.value_antialias_on);
        g2d.setrenderinghint(renderinghints.key_text_antialiasing,
                            renderinghints.value_text_antialias_on);
        
        // 转换坐标到可打印区域
        double pagewidth = pageformat.getimageablewidth();
        double pageheight = pageformat.getimageableheight();
        
        int x = (int) pageformat.getimageablex();
        int y = (int) pageformat.getimageabley();
        
        // 打印文本
        if (text != null && !text.isempty()) {
            printtext(g2d, x, y, pagewidth);
        }
        
        // 打印图片
        if (hasimage && image != null) {
            printimage(g2d, x, y, pagewidth, pageheight);
        }
        
        return page_exists;
    }
    
    private void printtext(graphics2d g2d, int x, int y, double pagewidth) {
        // 设置字体
        font font = new font("宋体", font.plain, 12);
        g2d.setfont(font);
        g2d.setcolor(color.black);
        
        // 计算文本布局
        fontmetrics metrics = g2d.getfontmetrics();
        int lineheight = metrics.getheight();
        int currenty = y + lineheight;
        
        // 处理换行
        string[] lines = text.split("\n");
        for (string line : lines) {
            // 如果一行太长，进行换行处理
            if (metrics.stringwidth(line) > pagewidth - 100) {
                printwrappedline(g2d, line, x + 50, currenty, 
                                (int)pagewidth - 100, metrics);
            } else {
                g2d.drawstring(line, x + 50, currenty);
            }
            currenty += lineheight;
        }
    }
    
    private void printwrappedline(graphics2d g2d, string line, 
                                 int x, int y, int maxwidth, fontmetrics metrics) {
        string[] words = line.split(" ");
        stringbuilder currentline = new stringbuilder();
        
        for (string word : words) {
            string testline = currentline + word + " ";
            if (metrics.stringwidth(testline) <= maxwidth) {
                currentline.append(word).append(" ");
            } else {
                if (currentline.length() > 0) {
                    g2d.drawstring(currentline.tostring(), x, y);
                    y += metrics.getheight();
                }
                currentline = new stringbuilder(word + " ");
            }
        }
        
        if (currentline.length() > 0) {
            g2d.drawstring(currentline.tostring(), x, y);
        }
    }
    
    private void printimage(graphics2d g2d, int x, int y, 
                           double pagewidth, double pageheight) {
        if (image == null) return;
        
        // 计算图片尺寸和位置
        int imgwidth = image.getwidth();
        int imgheight = image.getheight();
        
        // 调整图片大小以适应页面
        double scale = math.min(
            (pagewidth - 100) / imgwidth,
            (pageheight - 200) / imgheight
        );
        
        int scaledwidth = (int) (imgwidth * scale);
        int scaledheight = (int) (imgheight * scale);
        
        // 居中显示图片
        int imgx = x + (int)((pagewidth - scaledwidth) / 2);
        int imgy = y + (int)((pageheight - scaledheight) / 2) + 100;
        
        // 绘制图片
        g2d.drawimage(image, imgx, imgy, scaledwidth, scaledheight, null);
        
        // 添加图片边框
        g2d.setcolor(color.light_gray);
        g2d.drawrect(imgx - 1, imgy - 1, scaledwidth + 2, scaledheight + 2);
    }
    
    public static void main(string[] args) {
        try {
            // 示例1：打印文本
            string text = "这是一个打印测试文档。\n" +
                         "第二行文本内容。\n" +
                         "第三行文本内容，这一行比较长，用于测试自动换行功能。";
            
            documentprinter textprinter = new documentprinter(text);
            textprinter.printdocument();
            
            // 示例2：打印文本和图片
            bufferedimage image = imageio.read(new file("image.jpg"));
            documentprinter imageprinter = new documentprinter(text, image);
            imageprinter.printdocument();
            
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }
}

二、使用java print service api（更现代的方式）

import javax.print.*;
import javax.print.attribute.*;
import javax.print.attribute.standard.*;
import java.awt.print.*;
import java.io.*;
import java.util.locale;

public class printserviceexample {
    
    // 获取所有打印机
    public static void listprinters() {
        printservice[] services = printservicelookup.lookupprintservices(null, null);
        system.out.println("可用的打印机:");
        for (printservice service : services) {
            system.out.println(" - " + service.getname());
        }
    }
    
    // 使用指定打印机打印文本
    public static void printtospecificprinter(string text, string printername) {
        printservice[] services = printservicelookup.lookupprintservices(null, null);
        printservice selectedservice = null;
        
        // 查找指定打印机
        for (printservice service : services) {
            if (service.getname().equals(printername)) {
                selectedservice = service;
                break;
            }
        }
        
        if (selectedservice == null) {
            system.err.println("未找到打印机: " + printername);
            return;
        }
        
        // 创建打印作业
        docprintjob job = selectedservice.createprintjob();
        
        // 创建打印属性集
        printrequestattributeset attributes = new hashprintrequestattributeset();
        attributes.add(mediasizename.iso_a4);
        attributes.add(orientationrequested.portrait);
        attributes.add(new copies(1));
        
        // 创建打印文档
        byte[] bytes = text.getbytes();
        doc doc = new simpledoc(bytes, docflavor.byte_array.autosense, null);
        
        try {
            job.print(doc, attributes);
            system.out.println("打印任务已发送到: " + printername);
        } catch (printexception e) {
            system.err.println("打印失败: " + e.getmessage());
        }
    }
    
    // 打印html内容
    public static void printhtml(string htmlcontent) {
        try {
            // 创建临时html文件
            file tempfile = file.createtempfile("print", ".html");
            try (filewriter writer = new filewriter(tempfile)) {
                writer.write(htmlcontent);
            }
            
            // 使用默认程序打开并打印（windows）
            if (system.getproperty("os.name").tolowercase().contains("win")) {
                runtime.getruntime().exec(
                    "rundll32 url.dll,fileprotocolhandler " + 
                    tempfile.getabsolutepath()
                );
            }
            
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }
}

三、使用apache pdfbox库打印pdf

首先添加maven依赖：

<dependency>
    <groupid>org.apache.pdfbox</groupid>
    <artifactid>pdfbox</artifactid>
    <version>2.0.27</version>
</dependency>

import org.apache.pdfbox.pdmodel.*;
import org.apache.pdfbox.pdmodel.font.pdtype1font;
import org.apache.pdfbox.printing.pdfprintable;
import org.apache.pdfbox.printing.scaling;
import javax.print.*;
import javax.print.attribute.*;
import javax.print.attribute.standard.*;
import java.awt.print.*;
import java.io.*;

public class pdfprinter {
    
    // 创建pdf并打印
    public static void createandprintpdf(string text, string imagepath) {
        try (pddocument document = new pddocument()) {
            pdpage page = new pdpage();
            document.addpage(page);
            
            pdpagecontentstream contentstream = new pdpagecontentstream(
                document, page);
            
            // 添加文本
            contentstream.begintext();
            contentstream.setfont(pdtype1font.helvetica_bold, 12);
            contentstream.newlineatoffset(50, 750);
            contentstream.showtext(text);
            contentstream.endtext();
            
            // 添加图片
            if (imagepath != null) {
                pdimagexobject image = pdimagexobject.createfromfile(
                    imagepath, document);
                contentstream.drawimage(image, 100, 400, 300, 300);
            }
            
            contentstream.close();
            
            // 保存pdf
            document.save("document.pdf");
            
            // 打印pdf
            printpdf("document.pdf");
            
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }
    
    // 打印pdf文件
    public static void printpdf(string pdfpath) throws ioexception {
        try (pddocument document = pddocument.load(new file(pdfpath))) {
            printerjob job = printerjob.getprinterjob();
            job.setprintable(new pdfprintable(document, scaling.scale_to_fit));
            
            if (job.printdialog()) {
                job.print();
            }
        } catch (printerexception e) {
            e.printstacktrace();
        }
    }
    
    // 直接打印pdf（无对话框）
    public static void silentprintpdf(string pdfpath) throws ioexception {
        try (pddocument document = pddocument.load(new file(pdfpath))) {
            printerjob job = printerjob.getprinterjob();
            job.setprintable(new pdfprintable(document, scaling.scale_to_fit));
            job.print();
        } catch (printerexception e) {
            e.printstacktrace();
        }
    }
}

四、使用itext库打印

首先添加maven依赖：

<dependency>
    <groupid>com.itextpdf</groupid>
    <artifactid>itextpdf</artifactid>
    <version>5.5.13.3</version>
</dependency>

import com.itextpdf.text.*;
import com.itextpdf.text.pdf.*;
import java.io.*;
import java.awt.print.*;

public class itextprinter {
    
    public static void createpdfandprint(string text, string imagepath) {
        document document = new document();
        
        try {
            // 创建pdf文件
            pdfwriter writer = pdfwriter.getinstance(
                document, new fileoutputstream("output.pdf"));
            document.open();
            
            // 添加文本
            font font = fontfactory.getfont(fontfactory.helvetica, 12);
            paragraph paragraph = new paragraph(text, font);
            document.add(paragraph);
            
            // 添加图片
            if (imagepath != null) {
                image image = image.getinstance(imagepath);
                image.scaletofit(300, 300);
                document.add(image);
            }
            
            document.close();
            
            // 打印pdf
            printdocument("output.pdf");
            
        } catch (exception e) {
            e.printstacktrace();
        }
    }
    
    private static void printdocument(string filepath) {
        try {
            // 使用系统命令打印（windows）
            if (system.getproperty("os.name").tolowercase().contains("win")) {
                runtime.getruntime().exec(
                    "rundll32 shell32.dll,shellexec_rundll " +
                    "msprint2.dll,myprint " + filepath
                );
            } else {
                // linux/mac
                runtime.getruntime().exec("lpr " + filepath);
            }
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }
}

五、web应用中的打印（java servlet）

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.awt.print.*;

public class webprinterservlet extends httpservlet {
    
    protected void dopost(httpservletrequest request, 
                         httpservletresponse response) 
            throws servletexception, ioexception {
        
        string content = request.getparameter("content");
        string printername = request.getparameter("printer");
        
        // 在服务器端打印
        if (printonserver(content, printername)) {
            response.getwriter().write("打印任务已提交");
        } else {
            response.getwriter().write("打印失败");
        }
    }
    
    private boolean printonserver(string content, string printername) {
        try {
            printerjob job = printerjob.getprinterjob();
            
            // 设置打印机（如果指定）
            if (printername != null && !printername.isempty()) {
                printservice[] services = printerjob.lookupprintservices();
                for (printservice service : services) {
                    if (service.getname().equals(printername)) {
                        job.setprintservice(service);
                        break;
                    }
                }
            }
            
            job.setprintable(new printable() {
                @override
                public int print(graphics g, pageformat pf, int page) {
                    if (page > 0) return no_such_page;
                    
                    graphics2d g2d = (graphics2d) g;
                    g2d.setfont(new font("宋体", font.plain, 12));
                    g2d.drawstring(content, 100, 100);
                    
                    return page_exists;
                }
            });
            
            job.print();
            return true;
            
        } catch (printerexception e) {
            e.printstacktrace();
            return false;
        }
    }
    
    // 生成html页面，包含打印按钮
    protected void doget(httpservletrequest request, 
                        httpservletresponse response) 
            throws servletexception, ioexception {
        
        response.setcontenttype("text/html;charset=utf-8");
        printwriter out = response.getwriter();
        
        out.println("<html>");
        out.println("<head><title>打印测试</title>");
        out.println("<script>");
        out.println("function printcontent() {");
        out.println("  var content = document.getelementbyid('content').value;");
        out.println("  var printwindow = window.open('', '', 'width=800,height=600');");
        out.println("  printwindow.document.write('<html><head><title>打印</title></head><body>');");
        out.println("  printwindow.document.write('<pre>' + content + '</pre>');");
        out.println("  printwindow.document.write('</body></html>');");
        out.println("  printwindow.document.close();");
        out.println("  printwindow.print();");
        out.println("}");
        out.println("</script>");
        out.println("</head>");
        out.println("<body>");
        out.println("<h2>打印测试</h2>");
        out.println("<textarea id='content' rows='10' cols='50'></textarea><br>");
        out.println("<button onclick='printcontent()'>打印</button>");
        out.println("</body>");
        out.println("</html>");
    }
}

六、高级打印功能

import javax.print.*;
import javax.print.attribute.*;
import javax.print.attribute.standard.*;
import java.util.*;

public class advancedprinter {
    
    // 批量打印
    public static void batchprint(list<string> documents, string printername) {
        printservice printer = findprinter(printername);
        if (printer == null) {
            system.err.println("打印机未找到: " + printername);
            return;
        }
        
        docprintjob job = printer.createprintjob();
        printrequestattributeset attributes = new hashprintrequestattributeset();
        
        for (string doc : documents) {
            byte[] bytes = doc.getbytes();
            doc document = new simpledoc(bytes, 
                docflavor.byte_array.autosense, null);
            
            try {
                job.print(document, attributes);
                system.out.println("已打印文档: " + doc.substring(0, math.min(50, doc.length())));
                
                // 延迟一下，避免打印机过载
                thread.sleep(1000);
                
            } catch (exception e) {
                system.err.println("打印失败: " + e.getmessage());
            }
        }
    }
    
    // 查找打印机
    private static printservice findprinter(string printername) {
        printservice[] services = printservicelookup.lookupprintservices(null, null);
        for (printservice service : services) {
            if (service.getname().contains(printername)) {
                return service;
            }
        }
        return null;
    }
    
    // 获取打印机状态
    public static void checkprinterstatus(string printername) {
        printservice printer = findprinter(printername);
        if (printer == null) {
            system.out.println("打印机未找到");
            return;
        }
        
        attribute[] attributes = printer.getattributes().toarray();
        system.out.println("打印机状态: " + printer.getname());
        
        for (attribute attr : attributes) {
            system.out.println("  " + attr.getname() + ": " + attr);
        }
    }
    
    // 打印设置类
    public static class printsettings {
        private string printername;
        private int copies = 1;
        private boolean duplex = false;
        private mediasizename papersize = mediasizename.iso_a4;
        private orientationrequested orientation = orientationrequested.portrait;
        
        // getters and setters
        public string getprintername() { return printername; }
        public void setprintername(string printername) { this.printername = printername; }
        
        public int getcopies() { return copies; }
        public void setcopies(int copies) { this.copies = copies; }
        
        public boolean isduplex() { return duplex; }
        public void setduplex(boolean duplex) { this.duplex = duplex; }
        
        public mediasizename getpapersize() { return papersize; }
        public void setpapersize(mediasizename papersize) { this.papersize = papersize; }
        
        public orientationrequested getorientation() { return orientation; }
        public void setorientation(orientationrequested orientation) { this.orientation = orientation; }
    }
}

七、实用工具类

import java.awt.*;
import java.awt.print.*;
import javax.print.*;
import javax.print.attribute.*;
import java.io.*;
import java.util.*;

public class printutility {
    
    // 打印图片文件
    public static boolean printimagefile(file imagefile) {
        try {
            printerjob job = printerjob.getprinterjob();
            
            job.setprintable(new printable() {
                @override
                public int print(graphics g, pageformat pf, int pageindex) {
                    if (pageindex > 0) return no_such_page;
                    
                    graphics2d g2d = (graphics2d) g;
                    image image = toolkit.getdefaulttoolkit().getimage(
                        imagefile.getabsolutepath());
                    
                    // 等待图片加载
                    mediatracker tracker = new mediatracker(new component() {});
                    tracker.addimage(image, 0);
                    try {
                        tracker.waitforid(0);
                    } catch (interruptedexception e) {
                        e.printstacktrace();
                    }
                    
                    // 计算缩放比例
                    double pagewidth = pf.getimageablewidth();
                    double pageheight = pf.getimageableheight();
                    double imagewidth = image.getwidth(null);
                    double imageheight = image.getheight(null);
                    
                    double scale = math.min(
                        pagewidth / imagewidth,
                        pageheight / imageheight
                    );
                    
                    int scaledwidth = (int) (imagewidth * scale);
                    int scaledheight = (int) (imageheight * scale);
                    
                    // 居中绘制
                    int x = (int) pf.getimageablex() + 
                           (int) ((pagewidth - scaledwidth) / 2);
                    int y = (int) pf.getimageabley() + 
                           (int) ((pageheight - scaledheight) / 2);
                    
                    g2d.drawimage(image, x, y, scaledwidth, scaledheight, null);
                    
                    return page_exists;
                }
            });
            
            if (job.printdialog()) {
                job.print();
                return true;
            }
            
        } catch (exception e) {
            e.printstacktrace();
        }
        
        return false;
    }
    
    // 打印html到pdf再打印
    public static void printhtmlaspdf(string htmlcontent) {
        try {
            // 创建临时html文件
            file htmlfile = file.createtempfile("print", ".html");
            try (filewriter writer = new filewriter(htmlfile)) {
                writer.write(htmlcontent);
            }
            
            // 使用wkhtmltopdf转换为pdf（需要安装wkhtmltopdf）
            file pdffile = file.createtempfile("print", ".pdf");
            string command = string.format("wkhtmltopdf %s %s", 
                htmlfile.getabsolutepath(), pdffile.getabsolutepath());
            
            process process = runtime.getruntime().exec(command);
            process.waitfor();
            
            // 打印pdf
            printpdf(pdffile);
            
            // 清理临时文件
            htmlfile.delete();
            pdffile.delete();
            
        } catch (exception e) {
            e.printstacktrace();
        }
    }
    
    private static void printpdf(file pdffile) {
        // 使用系统打印命令
        try {
            string os = system.getproperty("os.name").tolowercase();
            
            if (os.contains("win")) {
                // windows
                runtime.getruntime().exec(
                    "rundll32 shell32.dll,shellexec_rundll " +
                    "msprint2.dll,myprint " + pdffile.getabsolutepath()
                );
            } else if (os.contains("mac")) {
                // mac
                runtime.getruntime().exec(
                    "lp " + pdffile.getabsolutepath()
                );
            } else {
                // linux
                runtime.getruntime().exec(
                    "lp " + pdffile.getabsolutepath()
                );
            }
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }
    
    // 测试方法
    public static void main(string[] args) {
        // 测试打印文本
        printerjob job = printerjob.getprinterjob();
        
        job.setprintable(new printable() {
            @override
            public int print(graphics g, pageformat pf, int page) {
                if (page > 0) return no_such_page;
                
                graphics2d g2d = (graphics2d) g;
                g2d.setfont(new font("arial", font.bold, 16));
                g2d.drawstring("测试打印", 100, 100);
                
                g2d.setfont(new font("arial", font.plain, 12));
                g2d.drawstring("当前时间: " + new date(), 100, 150);
                
                // 绘制表格
                int starty = 200;
                g2d.drawline(100, starty, 300, starty);
                g2d.drawstring("项目", 110, starty - 5);
                g2d.drawstring("数量", 210, starty - 5);
                
                starty += 30;
                g2d.drawstring("商品a", 110, starty);
                g2d.drawstring("10", 210, starty);
                
                return page_exists;
            }
        });
        
        try {
            if (job.printdialog()) {
                job.print();
            }
        } catch (printerexception e) {
            e.printstacktrace();
        }
    }
}

八、使用注意事项

1.依赖管理（maven）

<!-- pdfbox -->
<dependency>
    <groupid>org.apache.pdfbox</groupid>
    <artifactid>pdfbox</artifactid>
    <version>2.0.27</version>
</dependency>

<!-- itext -->
<dependency>
    <groupid>com.itextpdf</groupid>
    <artifactid>itextpdf</artifactid>
    <version>5.5.13.3</version>
</dependency>

<!-- 图形处理 -->
<dependency>
    <groupid>com.twelvemonkeys.imageio</groupid>
    <artifactid>imageio-core</artifactid>
    <version>3.8.2</version>
</dependency>

2.错误处理

public class safeprinter {
    public static boolean safeprint(runnable printtask) {
        try {
            printtask.run();
            return true;
        } catch (printerexception e) {
            system.err.println("打印机错误: " + e.getmessage());
            return false;
        } catch (securityexception e) {
            system.err.println("安全权限错误: " + e.getmessage());
            return false;
        } catch (exception e) {
            system.err.println("未知错误: " + e.getmessage());
            return false;
        }
    }
}

3.异步打印

public class asyncprinter {
    public static void printasync(string content) {
        new thread(() -> {
            try {
                printerjob job = printerjob.getprinterjob();
                job.setprintable((g, pf, page) -> {
                    // 打印逻辑
                    return page_exists;
                });
                job.print();
            } catch (printerexception e) {
                e.printstacktrace();
            }
        }).start();
    }
}

总结

选择打印方法：

简单文本打印：使用printerjob和printable接口
复杂文档打印：使用pdfbox或itext生成pdf后打印
web应用打印：使用servlet或生成html/pdf
跨平台需求：使用java内置api，或调用系统命令

注意事项：

java的打印api在不同操作系统上可能有差异
处理大图片时注意内存使用
生产环境中应添加完善的错误处理
考虑使用异步打印避免阻塞主线程
注意字体和编码问题（特别是中文）

以上就是java调用打印机打印图片和文本的多种方法的详细内容，更多关于java打印机打印图片和文本的资料请关注代码网其它相关文章！

Java调用打印机打印图片和文本的多种方法

2026年01月18日 • Java •我要评论

一、使用java内置的打印api

1.基本打印框架

2.完整打印类（支持文本和图片）

二、使用java print service api（更现代的方式）

三、使用apache pdfbox库打印pdf

四、使用itext库打印

五、web应用中的打印（java servlet）

六、高级打印功能

七、实用工具类

八、使用注意事项

1.依赖管理（maven）

2.错误处理

3.异步打印

总结

相关文章:

Java创建Web项目以及没有web.xml的解决方法

发表评论


验证码：