Apache PDFbox是一个开源的、基于Java的、支持PDF文档生成的工具库，它可以用于创建新的PDF文档，修改现有的PDF文档，还可以从PDF文档中提取所需的内容。Apache PDFBox还包含了数个命令行工具。

Apache PDFBox主要有以下特征：
PDF读取、创建、打印、转换、验证、合并分割等特征。

所需jar包

  1.         <dependency>
  2.             <groupId>org.apache.pdfbox</groupId>
  3.             <artifactId>pdfbox</artifactId>
  4.             <version>2.0.12</version>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>org.apache.pdfbox</groupId>
  8.             <artifactId>fontbox</artifactId>
  9.             <version>2.0.12</version>
  10.         </dependency>

文本内容提取

  1. // 
  2.     public static void PdfReader(String filePath){
  3.         File pdfFile  = new File(filePath);
  4.         PDDocument document = null;
  5.         try {
  6.             // PDF文件加载方式一
  7.            /*
  8.              InputStream input = null;
  9.              input = new FileInputStream( pdfFile );
  10.              //加载 pdf 文档
  11.              PDFParser parser = new PDFParser(new RandomAccessBuffer(input));
  12.              parser.parse();
  13.              document = parser.getPDDocument();
  14.              */
  16.             // PDF文件加载方式二
  17.             document=PDDocument.load(pdfFile);
  19.             // 获取页码
  20.             int pages = document.getNumberOfPages();
  22.             // 读文本内容
  23.             PDFTextStripper stripper=new PDFTextStripper();
  24.             // 设置按顺序输出
  25.             stripper.setSortByPosition(true);
  26.             stripper.setStartPage(1);
  27.             stripper.setEndPage(pages);
  28.             String content = stripper.getText(document);
  29.             System.out.println(content);
  30.         } catch(Exception e) {
  31.             e.printStackTrace();
  32.         }
  33.     }

图片提取

此方法可以取出源PDF中图片对象PDImageXObject，然后可以对该对象进行相关处理，本代码实现了将提取出来的每一个图片对象，插入到一个空白的PDF文档中。

  1.     public static void readImage(String filePath) throws IOException {
  3.         // 待解析PDF
  4.         File pdfFile = new File(filePath);
  5.         // 文件所在目录
  6.         String fileDirectory = pdfFile.getParent();
  7.         // 空白PDF - 内部没有任何内容的PDF
  8.         File pdfFileOut = new File(fileDirectory+"\\testout.pdf");
  10.         PDDocument document = null;
  11.         PDDocument documentOut = null;
  12.         try {
  13.             document = PDDocument.load(pdfFile);
  14.             documentOut = PDDocument.load(pdfFileOut);
  15.         } catch (IOException e) {
  16.             e.printStackTrace();
  17.         }
  19.         int pages_size = document == null ? 0:document.getNumberOfPages();
  20.         int j=0;
  22.         for(int i=0;i<pages_size;i++) {
  23.             PDPage page = document.getPage(i);
  24.             PDPage pageOut = documentOut ==null?null:documentOut.getPage(0);
  25.             PDResources resources = page.getResources();
  26.             Iterable xobjects = resources.getXObjectNames();
  28.             if (xobjects != null) {
  29.                 for (Object xobject : xobjects) {
  30.                     COSName key = (COSName) xobject;
  31.                     if (resources.isImageXObject(key)) {
  32.                         try {
  33.                             PDImageXObject image = (PDImageXObject) resources.getXObject(key);
  35.                             // 将PDF文档中的图片 分别存到一个空白PDF中。
  36.                             PDPageContentStream contentStream = new PDPageContentStream(documentOut, pageOut, PDPageContentStream.AppendMode.APPEND, true);
  38.                             float scale = 1f;
  39.                             contentStream.drawImage(image, 20, 20, image.getWidth() * scale, image.getHeight() * scale);
  40.                             contentStream.close();
  41.                             documentOut.save(fileDirectory + "/test" + j + ".pdf");
  43.                             System.out.println(image.getSuffix() + "," + image.getHeight() + "," + image.getWidth());
  45.                         } catch (IOException e) {
  46.                             // TODO Auto-generated catch block
  47.                             e.printStackTrace();
  48.                         }
  49.                         //image count
  50.                         j++;
  51.                     }
  52.                 }
  53.             }
  54.         }
  55.     }

PDF文件打印

  1.     /**
  2.      * 根据文档地址打印PDF文件
  3.      * @param filePath 文件地址
  4.      * @param printerName
  5.      * @throws Exception
  6.      */
  7.     public static void PdfPrint(File file , String printerName) throws Exception {
  8.         PDDocument document = null;
  9.         try {
  10.             document = PDDocument.load(file);
  11.             PrinterJob printJob = PrinterJob.getPrinterJob();
  12.             printJob.setJobName(file.getName());
  14.             // 获取默认打印机 PrintService printService = PrintServiceLookup.lookupDefaultPrintService();
  15.             if (printerName != null) {
  16.                 // 查找并设置打印机
  17.                 //获得本台电脑连接的所有打印机
  18.                 PrintService[] printServices = PrinterJob.lookupPrintServices();
  19.                 if(printServices == null || printServices.length == 0) {
  20.                     System.out.print("打印失败，未找到可用打印机，请检查。");
  21.                     return ;
  22.                 }
  23.                 PrintService printService = null;
  24.                 //匹配指定打印机
  25.                 for (int i = 0;i < printServices.length; i++) {
  26.                     //System.out.println(printServices[i].getName());
  27.                     if (printServices[i].getName().contains(printerName)) {
  28.                         printService = printServices[i];
  29.                         break;
  30.                     }
  31.                 }
  32.                 if(printService!=null){
  33.                     printJob.setPrintService(printService);
  34.                 }else{
  35.                     System.out.print("打印失败，未找到名称为" + printerName + "的打印机，请检查。");
  36.                     return ;
  37.                 }
  38.             }
  39.             //设置纸张及缩放
  40.             PDFPrintable pdfPrintable = new PDFPrintable(document, Scaling.ACTUAL_SIZE);
  41.             //设置多页打印
  42.             Book book = new Book();
  43.             PageFormat pageFormat = new PageFormat();
  44.             //设置打印方向
  45.             pageFormat.setOrientation(PageFormat.PORTRAIT);//纵向
  46.             pageFormat.setPaper(getPaper());//设置纸张
  47.             book.append(pdfPrintable, pageFormat, document.getNumberOfPages());
  48.             printJob.setPageable(book);
  49.             printJob.setCopies(1);//设置打印份数
  50.             //添加打印属性
  51.             HashPrintRequestAttributeSet pars = new HashPrintRequestAttributeSet();
  52.             pars.add(Sides.DUPLEX); //设置单双页
  53.             printJob.print(pars);
  54.         }finally {
  55.             if (document != null) {
  56.                 try {
  57.                     document.close();
  58.                 } catch (IOException e) {
  59.                     e.printStackTrace();
  60.                 }
  61.             }
  62.         }
  63.     }
  65.     /**
  66.      * 根据URL地址打印PDF文件
  67.      * @param urlStr url地址
  68.      * @param printerName 打印机名字
  69.      * @param orientation 1=竖向 2=横向
  70.      * @throws Exception
  71.      */
  72.     public static void PdfPrintByUrl(String urlStr ,String printerName ,Integer orientation) throws Exception {
  73.         PDDocument document = null;
  74.         try {
  75.             URL url = new URL(urlStr);
  76.             HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
  77.             httpURLConnection.setRequestProperty("Charset", "UTF-8");
  78.             httpURLConnection.setConnectTimeout(5*1000);
  79.             httpURLConnection.connect();
  80.             // 构造待打印的文件流
  81.             InputStream fis=httpURLConnection.getInputStream();
  83.             document = PDDocument.load(fis);
  84.             PrinterJob printJob = PrinterJob.getPrinterJob();
  86.             // 查找并设置打印机
  87.             //获得本台电脑连接的所有打印机
  88.             PrintService[] printServices = PrinterJob.lookupPrintServices();
  89.             if(printServices == null || printServices.length == 0) {
  90.                 System.out.print("打印失败，未找到可用打印机，请检查。");
  91.                 return ;
  92.             }
  93.             PrintService printService = null;
  94.             //匹配指定打印机
  95.             for (int i = 0;i < printServices.length; i++) {
  96.                 //System.out.println(printServices[i].getName());
  97.                 if (printServices[i].getName().contains(printerName)) {
  98.                     printService = printServices[i];
  99.                     break;
  100.                 }
  101.             }
  102.             if(printService!=null){
  103.                 printJob.setPrintService(printService);
  104.             }else{
  105.                 System.out.print("打印失败，未找到名称为" + printerName + "的打印机，请检查。");
  106.                 return ;
  107.             }
  109.             //设置纸张及缩放
  110.             PDFPrintable pdfPrintable = new PDFPrintable(document, Scaling.ACTUAL_SIZE);
  111.             //设置多页打印
  112.             Book book = new Book();
  113.             PageFormat pageFormat = new PageFormat();
  114.             //设置打印方向 PORTRAIT 竖向  REVERSE_LANDSCAPE 横向
  115.             pageFormat.setOrientation(orientation == 1 ? PageFormat.PORTRAIT : PageFormat.REVERSE_LANDSCAPE);
  116.             //设置纸张
  117.             pageFormat.setPaper(getPaper());
  118.             book.append(pdfPrintable, pageFormat, document.getNumberOfPages());
  119.             printJob.setPageable(book);
  120.             //设置打印份数
  121.             printJob.setCopies(1);
  122.             //添加打印属性
  123.             HashPrintRequestAttributeSet pars = new HashPrintRequestAttributeSet();
  124.             //设置单双页
  125.             pars.add(Sides.DUPLEX);
  126.             printJob.print(pars);
  127.         }finally {
  128.             if (document != null) {
  129.                 try {
  130.                     document.close();
  131.                 } catch (IOException e) {
  132.                     e.printStackTrace();
  133.                 }
  134.             }
  135.         }
  136.     }
  138.     public static Paper getPaper() {
  139.         Paper paper = new Paper();
  140.         // 默认为A4纸张，对应像素宽和高分别为 595, 842
  141.         int width = 595;
  142.         int height = 842;
  143.         // 设置边距，单位是像素，10mm边距，对应 28px
  144.         int marginLeft = 10;
  145.         int marginRight = 0;
  146.         int marginTop = 10;
  147.         int marginBottom = 0;
  148.         paper.setSize(width, height);
  149.         // 下面一行代码，解决了打印内容为空的问题
  150.         paper.setImageableArea(marginLeft, marginRight, width - (marginLeft + marginRight), height - (marginTop + marginBottom));
  151.         return paper;
  152.     }

PdfBoxUtils文件完整代码

  1. package com.example.demo.common;
  3. import org.apache.pdfbox.cos.COSName;
  4. import org.apache.pdfbox.pdmodel.PDDocument;
  5. import org.apache.pdfbox.pdmodel.PDPage;
  6. import org.apache.pdfbox.pdmodel.PDPageContentStream;
  7. import org.apache.pdfbox.pdmodel.PDResources;
  8. import org.apache.pdfbox.pdmodel.graphics.image.PDImageXObject;
  9. import org.apache.pdfbox.printing.PDFPrintable;
  10. import org.apache.pdfbox.printing.Scaling;
  11. import org.apache.pdfbox.text.PDFTextStripper;
  13. import javax.print.PrintService;
  14. import javax.print.PrintServiceLookup;
  15. import javax.print.attribute.HashPrintRequestAttributeSet;
  16. import javax.print.attribute.standard.Sides;
  17. import java.awt.print.Book;
  18. import java.awt.print.PageFormat;
  19. import java.awt.print.Paper;
  20. import java.awt.print.PrinterJob;
  21. import java.io.*;
  22. import java.net.HttpURLConnection;
  23. import java.net.URL;
  25. public class PDFBoxUtils {
  27.     public static void main(String[] args) throws Exception {
  28.         String filePath = "C:\\Users\\92384\\Documents\\test.pdf";//文件路径
  29.         //PdfReader(filePath);
  30.         readImage(filePath);
  31.         String printerName = "Microsoft Print to PDF";//打印机名包含字串
  32.         //PdfPrint(filePath,printerName);
  33.         String urlStr= "https://dlj.51fapiao.cn/dlj/v7/27a91fc541ac427967ef6d8f5019a98928f255";
  34.         //PdfPrintByUrl(urlStr,printerName,2);
  35.     }
  37.     public static void PdfReader(String filePath){
  38.         File pdfFile  = new File(filePath);
  39.         PDDocument document = null;
  40.         try {
  41.             // PDF文件加载方式一
  42.            /*
  43.              InputStream input = null;
  44.              input = new FileInputStream( pdfFile );
  45.              //加载 pdf 文档
  46.              PDFParser parser = new PDFParser(new RandomAccessBuffer(input));
  47.              parser.parse();
  48.              document = parser.getPDDocument();
  49.              */
  51.             // PDF文件加载方式二
  52.             document=PDDocument.load(pdfFile);
  54.             // 获取页码
  55.             int pages = document.getNumberOfPages();
  57.             // 读文本内容
  58.             PDFTextStripper stripper=new PDFTextStripper();
  59.             // 设置按顺序输出
  60.             stripper.setSortByPosition(true);
  61.             stripper.setStartPage(1);
  62.             stripper.setEndPage(pages);
  63.             String content = stripper.getText(document);
  64.             System.out.println(content);
  65.         } catch(Exception e) {
  66.             e.printStackTrace();
  67.         }
  68.     }
  70.     public static void readImage(String filePath) throws IOException {
  72.         // 待解析PDF
  73.         File pdfFile = new File(filePath);
  74.         // 文件所在目录
  75.         String fileDirectory = pdfFile.getParent();
  76.         // 空白PDF - 内部没有任何内容的PDF
  77.         File pdfFileOut = new File(fileDirectory+"\\testout.pdf");
  79.         PDDocument document = null;
  80.         PDDocument documentOut = null;
  81.         try {
  82.             document = PDDocument.load(pdfFile);
  83.             documentOut = PDDocument.load(pdfFileOut);
  84.         } catch (IOException e) {
  85.             e.printStackTrace();
  86.         }
  88.         int pages_size = document == null ? 0:document.getNumberOfPages();
  89.         int j=0;
  91.         for(int i=0;i<pages_size;i++) {
  92.             PDPage page = document.getPage(i);
  93.             PDPage pageOut = documentOut ==null?null:documentOut.getPage(0);
  94.             PDResources resources = page.getResources();
  95.             Iterable xobjects = resources.getXObjectNames();
  97.             if (xobjects != null) {
  98.                 for (Object xobject : xobjects) {
  99.                     COSName key = (COSName) xobject;
  100.                     if (resources.isImageXObject(key)) {
  101.                         try {
  102.                             PDImageXObject image = (PDImageXObject) resources.getXObject(key);
  104.                             // 将PDF文档中的图片 分别存到一个空白PDF中。
  105.                             PDPageContentStream contentStream = new PDPageContentStream(documentOut, pageOut, PDPageContentStream.AppendMode.APPEND, true);
  107.                             float scale = 1f;
  108.                             contentStream.drawImage(image, 20, 20, image.getWidth() * scale, image.getHeight() * scale);
  109.                             contentStream.close();
  110.                             documentOut.save(fileDirectory + "/test" + j + ".pdf");
  112.                             System.out.println(image.getSuffix() + "," + image.getHeight() + "," + image.getWidth());
  114.                         } catch (IOException e) {
  115.                             // TODO Auto-generated catch block
  116.                             e.printStackTrace();
  117.                         }
  118.                         //image count
  119.                         j++;
  120.                     }
  121.                 }
  122.             }
  123.         }
  124.     }
  126.     /**
  127.      * 根据文档地址打印PDF文件
  128.      * @param filePath 文件地址
  129.      * @param printerName
  130.      * @throws Exception
  131.      */
  132.     public static void PdfPrint(String filePath , String printerName) throws Exception {
  133.         File file = null;
  134.         PDDocument document = null;
  135.         try {
  136.             file = new File(filePath);
  137.             document = PDDocument.load(file);
  138.             PrinterJob printJob = PrinterJob.getPrinterJob();
  139.             printJob.setJobName(file.getName());
  141.             // 获取默认打印机 PrintService printService = PrintServiceLookup.lookupDefaultPrintService();
  142.             if (printerName != null) {
  143.                 // 查找并设置打印机
  144.                 //获得本台电脑连接的所有打印机
  145.                 PrintService[] printServices = PrinterJob.lookupPrintServices();
  146.                 if(printServices == null || printServices.length == 0) {
  147.                     System.out.print("打印失败，未找到可用打印机，请检查。");
  148.                     return ;
  149.                 }
  150.                 PrintService printService = null;
  151.                 //匹配指定打印机
  152.                 for (int i = 0;i < printServices.length; i++) {
  153.                     //System.out.println(printServices[i].getName());
  154.                     if (printServices[i].getName().contains(printerName)) {
  155.                         printService = printServices[i];
  156.                         break;
  157.                     }
  158.                 }
  159.                 if(printService!=null){
  160.                     printJob.setPrintService(printService);
  161.                 }else{
  162.                     System.out.print("打印失败，未找到名称为" + printerName + "的打印机，请检查。");
  163.                     return ;
  164.                 }
  165.             }
  166.             //设置纸张及缩放
  167.             PDFPrintable pdfPrintable = new PDFPrintable(document, Scaling.ACTUAL_SIZE);
  168.             //设置多页打印
  169.             Book book = new Book();
  170.             PageFormat pageFormat = new PageFormat();
  171.             //设置打印方向
  172.             pageFormat.setOrientation(PageFormat.PORTRAIT);//纵向
  173.             pageFormat.setPaper(getPaper());//设置纸张
  174.             book.append(pdfPrintable, pageFormat, document.getNumberOfPages());
  175.             printJob.setPageable(book);
  176.             printJob.setCopies(1);//设置打印份数
  177.             //添加打印属性
  178.             HashPrintRequestAttributeSet pars = new HashPrintRequestAttributeSet();
  179.             pars.add(Sides.DUPLEX); //设置单双页
  180.             printJob.print(pars);
  181.         }finally {
  182.             if (document != null) {
  183.                 try {
  184.                     document.close();
  185.                 } catch (IOException e) {
  186.                     e.printStackTrace();
  187.                 }
  188.             }
  189.         }
  190.     }
  192.     /**
  193.      * 根据URL地址打印PDF文件
  194.      * @param urlStr url地址
  195.      * @param printerName 打印机名字
  196.      * @param orientation 1=竖向 2=横向
  197.      * @throws Exception
  198.      */
  199.     public static void PdfPrintByUrl(String urlStr ,String printerName ,Integer orientation) throws Exception {
  200.         PDDocument document = null;
  201.         try {
  202.             URL url = new URL(urlStr);
  203.             HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
  204.             httpURLConnection.setRequestProperty("Charset", "UTF-8");
  205.             httpURLConnection.setConnectTimeout(5*1000);
  206.             httpURLConnection.connect();
  207.             // 构造待打印的文件流
  208.             InputStream fis=httpURLConnection.getInputStream();
  210.             document = PDDocument.load(fis);
  211.             PrinterJob printJob = PrinterJob.getPrinterJob();
  213.             // 查找并设置打印机
  214.             //获得本台电脑连接的所有打印机
  215.             PrintService[] printServices = PrinterJob.lookupPrintServices();
  216.             if(printServices == null || printServices.length == 0) {
  217.                 System.out.print("打印失败，未找到可用打印机，请检查。");
  218.                 return ;
  219.             }
  220.             PrintService printService = null;
  221.             //匹配指定打印机
  222.             for (int i = 0;i < printServices.length; i++) {
  223.                 //System.out.println(printServices[i].getName());
  224.                 if (printServices[i].getName().contains(printerName)) {
  225.                     printService = printServices[i];
  226.                     break;
  227.                 }
  228.             }
  229.             if(printService!=null){
  230.                 printJob.setPrintService(printService);
  231.             }else{
  232.                 System.out.print("打印失败，未找到名称为" + printerName + "的打印机，请检查。");
  233.                 return ;
  234.             }
  236.             //设置纸张及缩放
  237.             PDFPrintable pdfPrintable = new PDFPrintable(document, Scaling.ACTUAL_SIZE);
  238.             //设置多页打印
  239.             Book book = new Book();
  240.             PageFormat pageFormat = new PageFormat();
  241.             //设置打印方向 PORTRAIT 竖向  REVERSE_LANDSCAPE 横向
  242.             pageFormat.setOrientation(orientation == 1 ? PageFormat.PORTRAIT : PageFormat.REVERSE_LANDSCAPE);
  243.             //设置纸张
  244.             pageFormat.setPaper(getPaper());
  245.             book.append(pdfPrintable, pageFormat, document.getNumberOfPages());
  246.             printJob.setPageable(book);
  247.             //设置打印份数
  248.             printJob.setCopies(1);
  249.             //添加打印属性
  250.             HashPrintRequestAttributeSet pars = new HashPrintRequestAttributeSet();
  251.             //设置单双页
  252.             pars.add(Sides.DUPLEX);
  253.             printJob.print(pars);
  254.         }finally {
  255.             if (document != null) {
  256.                 try {
  257.                     document.close();
  258.                 } catch (IOException e) {
  259.                     e.printStackTrace();
  260.                 }
  261.             }
  262.         }
  263.     }
  265.     public static Paper getPaper() {
  266.         Paper paper = new Paper();
  267.         // 默认为A4纸张，对应像素宽和高分别为 595, 842
  268.         int width = 595;
  269.         int height = 842;
  270.         // 设置边距，单位是像素，10mm边距，对应 28px
  271.         int marginLeft = 10;
  272.         int marginRight = 0;
  273.         int marginTop = 10;
  274.         int marginBottom = 0;
  275.         paper.setSize(width, height);
  276.         // 下面一行代码，解决了打印内容为空的问题
  277.         paper.setImageableArea(marginLeft, marginRight, width - (marginLeft + marginRight), height - (marginTop + marginBottom));
  278.         return paper;
  279.     }
  280. }