pdf导入excel表格
 

  
 
 
Excel provides a plethora of features for organizing, manipulating, and handling your data. One of these unique features is inserting a PDF directly into Excel. The good news is it only involves a few simple steps to do it. Here’s how.
 
 
 Excel提供了许多功能来组织，处理和处理数据。 这些独特功能之一是将PDF直接插入Excel。 好消息是它仅涉及几个简单的步骤即可完成。 这是如何做。 
 
 
 将PDF插入Excel (Inserting a PDF Into Excel)
 
 
In the Excel file, head over to the “Insert” tab and then click the “Object” button.
 
 
 在Excel文件中，转到“插入”选项卡，然后单击“对象”按钮。 
 
 

  
 
 
In the Object window that appears, switch to the “Create from File” tab and then click “Browse.”
 
 
 在出现的“对象”窗口中，切换到“从文件创建”选项卡，然后单击“浏览”。 
 
 

  
 
 
Browse to the location of your file, select the file, and then click “Open.”
 
 
 浏览到文件的位置，选择文件，然后单击“打开”。 
 
 

  
 
 
Back at the “Object” window, you’ll see the file path of your PDF. Now, you need to tell Excel how you want the file to appear in the spreadsheet. There are a few different options here. If you select “OK” without taking any further action in the “Object” window, the PDF file appears in Excel showing the contents of the PDF in its entirety.
 
 
 返回“对象”窗口，您将看到PDF的文件路径。 现在，您需要告诉Excel您希望文件如何出现在电子表格中。 这里有一些不同的选择。 如果您选择“确定”而不在“对象”窗口中进行任何进一步的操作，则PDF文件将显示在Excel中，以完整显示PDF的内容。 
 
 

  
 
 
Alternatively, you can check the box next to “Display as icon” for a less intrusive option. This method, as the name suggests, inserts an icon that represents the contents of your file. Double-clicking the icon opens the file in your computer’s default PDF viewer.
 
 
 或者，您可以选中“显示为图标”旁边的框，以减少干扰。 顾名思义，此方法将插入一个代表文件内容的图标。 双击图标可在计算机的默认PDF查看器中打开文件。 
 
 

  
 
 
Another solution would be to check the “Link to file” option. This option, as with the others, places the content of your PDF into Excel. The difference here is that it creates a link to the source file, making it a live document. Any changes to the source file would be reflected in your document.
 
 
 另一个解决方案是选中“链接到文件”选项。 与其他选项一样，此选项将PDF的内容放入Excel。 此处的区别在于，它创建了到源文件的链接，从而使其成为实时文档。 对源文件的任何更改都将反映在您的文档中。 
 
 
Also keep in mind that you can select both the “Link to file” and “Display as icon” options, creating a less intrusive method of accessing a live document.
 
 
 还请记住，您可以同时选择“链接到文件”和“显示为图标”选项，从而创建一种访问实时文档的方法，但不太麻烦。 
 
 
Once you’ve selected the option that works best for you, click “OK.”
 
 
 选择最适合您的选项后，点击“确定”。 
 
 

  
 
 
Your PDF will now be inserted into Excel as an icon.
 
 
 您的PDF现在将作为图标插入到Excel中。 
 
 

  
 
 
You’ll notice that once inserted, the PDF takes on an “In front of text” layout style and hovers above the cells. If you want to anchor the PDF to (and format with) a specific cell, then right-click the icon and select “Format Object” from the drop-down menu.
 
 
 您会注意到，一旦插入，PDF就会呈现“文本前面”的布局样式，并悬停在单元格上方。 如果要将PDF锚定到特定单元格(并使用其格式化)，请右键单击该图标，然后从下拉菜单中选择“格式化对象”。 
 
 

  
 
 
The “Format Object” window will now appear. There are several different things you can do here, including changing the size and color, cropping, and even adding alt text to the object. What we’re particularly interested in here, though, is object positioning.
 
 
 现在将出现“格式化对象”窗口。 您可以在此处执行几项不同的操作，包括更改大小和颜色，裁剪，甚至向对象添加替代文本 。 不过，我们在这里特别感兴趣的是对象定位。 
 
 
First, select the “Properties” tab. You’ll find a few options concerning the positioning of the object. Here, select “Move and size with cells” and then click “OK.”
 
 
 首先，选择“属性”标签。 您会发现一些有关对象位置的选项。 在这里，选择“使用单元格移动并调整大小”，然后单击“确定”。 
 
 
Note: If you don’t want the icon to appear in the printed version of the sheet, untick the “Print object” checkbox.
 
 
 注意：如果您不希望图标出现在印张上，请取消选中“打印对象”复选框。 
 
 

  
 
 
Now any changes made to the cell, including hiding or resizing, will also apply to the icon.
 
 
 现在，对该单元格所做的任何更改(包括隐藏或调整大小)也将应用于该图标。 
 
 

  
 
 
Repeat these steps to insert multiple PDF files in your Excel sheet.
 
 
 重复这些步骤，以在Excel工作表中插入多个PDF文件。 
 
 

  
翻译自: https://www.howtogeek.com/414524/how-to-insert-a-pdf-into-excel/
 
 
pdf导入excel表格

最近项目中遇到导出PDF 出现折行的情况；
 
我们的需求是  先行导出Excel  ，在把Excel转成PDF 格式；
 
可是在转PDF时，由于Excel 列多，导出 出现了 折行；
 
如下图是我的Excel：
 
 
没处理前导出PDF为：
 
 
 
 
处理后：
 
 
最后找到原因：在Excel转PDF 时，使页面放在一张；
 
方法一：
 
附上我Excel 转 PDF的代码；
 
 /**
       * excel转pdf   请款单转PDF时由于列多 导致折行显示 效果不行
       * @param inPath
       * @param outPath
       * 会在一页放置数据，不会折页
       */
      public static void excelToPdf(String inFilePath, String outFilePath) throws Exception {
          if (!getLicense()) {          // 验证License 若不验证则转化出的pdf文档会有水印产生           
                 return;       
             }      
             try {           
                 File pdfFile = new File(outFilePath);// 输出路径           
                 Workbook wb = new Workbook(inFilePath);// 原始excel路径     
                 PdfSaveOptions pdfSaveOptions = new PdfSaveOptions();
                 pdfSaveOptions.setOnePagePerSheet(true);//把内容放在一张PDF 页面上；
                 FileOutputStream fileOS = new FileOutputStream(pdfFile);           
                 wb.save(fileOS, pdfSaveOptions);//  只放一张纸；我的专为横向了
                 //wb.save(fileOS, SaveFormat.PDF);  //不做限制 ，   导出的为纵向        
                 fileOS.close();                 
             }catch (Exception e) {           
                 e.printStackTrace();       
             }
      }
 
public static boolean getLicense() {       
         boolean result = false;       
         try {           
             InputStream is = ExcelToPdfUtils.class.getClassLoader().getResourceAsStream("license.xml"); //  license.xml应放在..\WebRoot\WEB-INF\classes路径下           
             License aposeLic = new License();           
             aposeLic.setLicense(is);           
             result = true;       
         }catch (Exception e) {                          
             e.printStackTrace();       
         }       
             return result;   
     } 
 
方法二：
 
在有就是 在Excel生成时，设置 打印缩放比例：
 
HSSFPrintSetup print = (HSSFPrintSetup) sheet1.getPrintSetup(); 
                 print.setScale((short) 87);//设置打印缩放% 

这个缩放的比例不是很准确，但还凑合能用，目前本人找不到其它方法，就先用这个。
 
先看一个关键的API方法：void org.apache.poi.ss.usermodel.Picture.resize(double scaleX, double scaleY)，一定要清楚这个方法中的参数 scaleX 和 scaleY 的比例是最终图片的宽高与单元格宽高的比例，不是与原图片宽高的比例。（而且当scaleX=1时，按道理应该占满单元格，但我测试后一直占不满不知道为什么，这可能也是最后比例不准确的原因之一）
 
测试代码在下面，大体说明一下这个代码：根据旧的excel，生成新的excel，新的excel需要在原有基础上插入一个图片，插入图片的位置是批注为“img”的单元格，生成的图片宽是70PX（可以根据参数调整），高度是根据最终图片宽度与原图的比例调整的，如果原图的宽度小于70PX，则直接插入原图。引入需要的依赖后，创建新类复制代码，可直接测试，缩放图片的关键部分都有注释，这是写好的业务代码，不是demo，所以有些冗长，可根据自身需要删除不必要的部分。
 
package com.buptnu.excel;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PushbackInputStream;

import javax.imageio.ImageIO;

import org.apache.poi.POIXMLDocument;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.openxml4j.opc.OPCPackage;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.ClientAnchor;
import org.apache.poi.ss.usermodel.Comment;
import org.apache.poi.ss.usermodel.CreationHelper;
import org.apache.poi.ss.usermodel.Drawing;
import org.apache.poi.ss.usermodel.Picture;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.util.IOUtils;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class ExcelUtils {
	
	/**
	 * 生成Excel
	 * @param targetPath 原excel文件地址
	 * @param imgPath 图片地址
	 * @param newFilePath 生成的新excel文件地址
	 * @param width 生成的新的图片宽度，单位是像素
	 */
	public static void dataExportExcel(String targetPath, String imgPath, String newFilePath, double width) {
		InputStream input = null;
		OutputStream output = null;
		Workbook workbook = null;
		try {
			input = new FileInputStream(targetPath);
			if (!input.markSupported()) {
				input = new PushbackInputStream(input, 8);
			}
			if (POIFSFileSystem.hasPOIFSHeader(input)) {
				workbook= new HSSFWorkbook(input);// excel 2003
		    } else if (POIXMLDocument.hasOOXMLHeader(input)) {
		    	workbook = new XSSFWorkbook(OPCPackage.open(input));// excel 2007
		    }
			Sheet sheet = workbook.getSheetAt(0);
			for (int i = 0; i < sheet.getLastRowNum() + 1; i++) {
				Row row = sheet.getRow(i);
				if (row == null) {
					continue;
				}
				for (int j = 0; j < row.getLastCellNum(); j++) {
					Cell cell = row.getCell(j);
					if (cell == null) {
						continue;
					}
					Comment comment = cell.getCellComment();
					if (comment == null) {
						continue;
					}
					String commentValue = comment.getString().getString().trim();
					if (commentValue.equals("img")) {
						ExcelUtils.replaceImage(workbook, sheet, cell, imgPath, j, i, width);
					}
					cell.removeCellComment();
				}
			}
			File file = new File(newFilePath);
			if (!file.exists()) {
				file.createNewFile();
			}
			output = new FileOutputStream(newFilePath);
			workbook.write(output);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (input != null) {
				try {
					input.close();
				} catch (IOException e) { }
			}
			if (output != null) {
				try {
					output.close();
				} catch (IOException e) { }
			}
		}
	}
	
	/**
	 * 替换图片
	 * @param book
	 * @param sheet
	 * @param cell
	 * @param jdImagePath
	 * @param jdcol
	 * @param jdrow
	 * @param width
	 * @return
	 * @throws Exception
	 */
	public static Workbook replaceImage(Workbook book, Sheet sheet, Cell cell, String jdImagePath, int jdcol, int jdrow, double width) throws Exception {
    	InputStream jdis;
    	byte[] jdbytes = null;
		try {
			jdis = new FileInputStream(jdImagePath);
			jdbytes = IOUtils.toByteArray(jdis);
		} catch (Exception e) {
			e.printStackTrace();
		}
    	CreationHelper helper = book.getCreationHelper();  
    	Drawing drawing  = null;
    	if (sheet instanceof XSSFSheet) {
    		XSSFSheet xSSFSheet = (XSSFSheet)sheet;
    		drawing = xSSFSheet.getDrawingPatriarch();
    	} else if (sheet instanceof HSSFSheet) {
    		HSSFSheet hSSFSheet = (HSSFSheet)sheet;
    		drawing = hSSFSheet.getDrawingPatriarch();
    	}
    	if (drawing == null) {
    		drawing = sheet.createDrawingPatriarch(); 
    	}
    	// 图片插入坐标  
    	if (-1 != jdcol && -1 != jdrow) {
    		int jdpictureIdx = book.addPicture(jdbytes, Workbook.PICTURE_TYPE_JPEG);// 根据需要调整参数，如果是PNG，就改为 Workbook.PICTURE_TYPE_PNG
    		ClientAnchor jdanchor = helper.createClientAnchor();  
	    	jdanchor.setCol1(jdcol);
	    	jdanchor.setRow1(jdrow);
	    	// 获取原图片的宽度和高度，单位都是像素
	    	File image = new File(jdImagePath);
	    	BufferedImage sourceImg = ImageIO.read(image);
	    	double imageWidth = sourceImg.getWidth();
	    	double imageHeight = sourceImg.getHeight();
	    	// 获取单元格宽度和高度，单位都是像素
	    	double cellWidth = sheet.getColumnWidthInPixels(cell.getColumnIndex());
	    	double cellHeight = cell.getRow().getHeightInPoints() / 72 * 96;// getHeightInPoints()方法获取的是点（磅），就是excel设置的行高，1英寸有72磅，一般显示屏一英寸是96个像素
	    	// 插入图片，如果原图宽度大于最终要求的图片宽度，就按比例缩小，否则展示原图
	    	Picture pict = drawing.createPicture(jdanchor, jdpictureIdx);
	    	if (imageWidth > width) {
	    		double scaleX = width / cellWidth;// 最终图片大小与单元格宽度的比例
	    		// 最终图片大小与单元格高度的比例
	    		// 说一下这个比例的计算方式吧：( imageHeight / imageWidth ) 是原图高于宽的比值，则 ( width * ( imageHeight / imageWidth ) ) 就是最终图片高的比值，
	    		// 那 ( width * ( imageHeight / imageWidth ) ) / cellHeight 就是所需比例了
		    	double scaleY = ( width * ( imageHeight / imageWidth ) ) / cellHeight;
	    		pict.resize(scaleX, scaleY);
	    	} else {
	    		pict.resize();
	    	}
    	}
    	return book;
    }
	
	public static void main(String[] args) {
		ExcelUtils.dataExportExcel("F:\\test.xlsx", "F:\\test1.jpg", "F:\\test2.xlsx", 70);
	}
	
}
 
maven的POI依赖：
 
        <dependency>
           <groupId>org.jxls</groupId> 
           <artifactId>jxls-poi</artifactId> 
           <version>1.0.9</version> 
         </dependency>
 
        <dependency>
             <groupId>org.apache.poi</groupId>
             <artifactId>poi</artifactId>
             <version>3.12</version>
         </dependency>
 
 

需求：将Excel转化为PDF，支持图片，只单个sheet
 
要求：1、开源免费；2、支持跨平台
 
设计：1. 采用POI读取Excel文件；2. 采用itext生成PDF文件。
 
注：如果费用许可的情况下，建议使用Aspose（可跨平台，收费，不开源）。
 
开发难点：
 
1. 将POI标准转化为Itext标准，包括单元格内容，字体，样式，单元格的合并等；
 
2. Excel文件x轴可以滚动，而PDF文件宽度是固定的，转化后的PDF内容可能会出现挤压的情况。
 
思路：1. 先将poi对转化为标准对象，如将POI的颜色转化为RGB；2. 将标准对象转化为itext对象。
 
转换事项：
 
1. 单元格类型：常规、数值、文本等。
 
2. 对齐方式：水平对齐只支持左对齐、居中、右对齐，默认左对齐；垂直对齐方式只顶端对齐、垂直居中、底端对齐，默认底端对齐。
 
3. 文本的字体（暂不支持，目前固定为STSong-Light）、颜色（支持）、大小（支持）、是否加粗（支持），是否倾斜（支持），是否有下划线（支持），是否自动换行（支持）
 
4. 框线：下框线、上框线、左框线、右框线（仅设置边框颜色和边框宽度）
 
5. 填充色（背景色）：支持。
 
6. 单元格的高度和宽度
 
遗留问题（后续改善）：
 
1. excel不支持黑色背景。
 
2. excel相邻单元格都有边框时，PDF文件边框变粗。
 
3. 当excel单元格处在图片区域，PDF中该单元格无文本。
 
4. 当excel文件存在多张图片有重合区域时，PDF只有其中的一张图片（起始单元格最靠前的图片）。
 
5. excel单元格字体加粗、倾斜、下划线，pdf只有加粗、下划线，缺少倾斜。
 
6. 部分情况pdf样式失真。
 
7.目前该文主要是验证excel转pdf，后期会更新优化后方案。
 
示例（excel2003文件转化为pdf）
 
excel2003文件：
 
 
转化后的PDF文件：
 
 
 
 
测试代码：
 
// poi和itext将Excel转化为PDF（支持图片）
String pdf = "F:/Users/zyj/Desktop/2019-09-27 自由报表/插件测试/excel2pdf_new.pdf";
Xls2Pdf xls2Pdf = new Xls2Pdf(xls, 0);
xls2Pdf.savePdf(pdf);
 
poi读取xls文件，生成PDF的代码：
 
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.Map;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFPictureData;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.util.CellRangeAddress;

import com.itextpdf.text.BadElementException;
import com.itextpdf.text.Document;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.Image;
import com.itextpdf.text.Phrase;
import com.itextpdf.text.Rectangle;
import com.itextpdf.text.pdf.PdfPCell;
import com.itextpdf.text.pdf.PdfPTable;
import com.itextpdf.text.pdf.PdfWriter;

/**
 * Excel2003文件转化为PDF文件
 * 
 * @author zyj
 * @date 2019-10-18
 */
public class Xls2Pdf {
	private HSSFWorkbook _wb = null;
	private int _sheetIndex = 0;
	private HSSFSheet _sheet = null;
	// 文本中的合并单元格
	private List<CellRangeAddress> _ranges = null;
	// 单个Sheet中所有的图片信息
	private Map<String, HSSFPictureData> _pics = null;
	// 图片中的最后一个单元格位置
	private Integer[] _lastCell = null;

	/**
	 * 构造函数
	 * 
	 * @param excel      excel2003文件的全路径
	 * @param sheetindex sheet索引
	 * @throws IOException
	 */
	public Xls2Pdf(String excel, int sheetIndex) throws IOException {
		InputStream input = new FileInputStream(excel);
		HSSFWorkbook wb = new HSSFWorkbook(input);
		this._wb = wb;
		this._sheetIndex = sheetIndex;
	}

	/**
	 * 构造函数
	 * 
	 * @param wb         excel工作薄
	 * @param sheetIndex sheet索引
	 */
	public Xls2Pdf(HSSFWorkbook wb, int sheetIndex) {
		this._wb = wb;
		this._sheetIndex = sheetIndex;
	}

	/**
	 * 保存为pdf文件
	 * 
	 * @param pdf pdf文件的全路径
	 * @throws IOException
	 * @throws BadElementException
	 * @throws DocumentException
	 */
	public void savePdf(String pdf) throws IOException, BadElementException, DocumentException {
		PdfPTable table = this.genPdfPTable();
		// Step 1 — Create a Document
		Document document = new Document();
		// Step 2 — Get a PdfWriter instance
		FileOutputStream output = new FileOutputStream(pdf);
		PdfWriter.getInstance(document, output);
		// Step 3 — Open the Document
		document.open();
		// Step 4 — Add content.
		document.add(table);
		// Step 5 — Close the Document
		document.close();
	}

	/**
	 * 将sheet转化为PdfPTable
	 * 
	 * @return PdfPTable对象
	 * @throws IOException
	 * @throws BadElementException
	 * @throws DocumentException
	 */
	public PdfPTable genPdfPTable() throws IOException, BadElementException, DocumentException {
		if (this._wb == null) {
			return null;
		}
		this._sheet = this._wb.getSheetAt(this._sheetIndex);
		if (this._sheet == null) {
			return null;
		}
		// 文本中的合并单元格
		this._ranges = this._sheet.getMergedRegions();
		// sheet中所有图片信息
		this._pics = XlsHelper.getPictrues(this._wb, this._sheetIndex);
		// sheet中最后一个单元格位置
		this._lastCell = this.getLastCell();
		PdfPTable table = new PdfPTable(this._lastCell[1] + 1);
		// 遍历Sheet中的所有行
		for (int i = 0; i <= this._lastCell[0]; i++) {
			for (int j = 0; j <= this._lastCell[1]; j++) {
				PdfPCell pdfpCell = this.genPdfPCell(i, j);
				if (pdfpCell == null) {
					continue;
				}
				table.addCell(pdfpCell);
				j += pdfpCell.getColspan() - 1;
			}
		}
		// sheet中每列的宽度
		float totalWidth = 0;
		float[] widths = new float[this._lastCell[1] + 1];
		for (int i = 0; i <= this._lastCell[1]; i++) {
			widths[i] = this._sheet.getColumnWidthInPixels(i);
			totalWidth += widths[i];
		}
		// PDF宽度固定
		table.setWidths(widths);
		table.setTotalWidth(totalWidth);
		table.setLockedWidth(true);
		return table;
	}

	/**
	 * 将Exel单元格转化为PDF单元格
	 * 
	 * @param rowIndex 行号
	 * @param colIndex 列号
	 * @return PDF单元格
	 * @throws IOException
	 * @throws BadElementException
	 */
	private PdfPCell genPdfPCell(int rowIndex, int colIndex) throws IOException, BadElementException {
		// 如果该位置是合并区域的单元格，跳过。
		if (this.merged(rowIndex, colIndex)) {
			return null;
		}
		// 是否为图片的起始单元格
		boolean isImg = this.imgCell(rowIndex, colIndex);
		PdfPCell pdfpCell = null;
		HSSFRow row = this._sheet.getRow(rowIndex);
		if (row == null) {
			// 空单元格，无边框
			pdfpCell = new PdfPCell();
			pdfpCell.setBorder(Rectangle.NO_BORDER);
		} else {
			HSSFCell cell = row.getCell(colIndex);
			// 空单元格的处理
			if (cell == null) {
				cell = row.createCell(colIndex);
			}
			pdfpCell = Xls2PdfObject.parsePdfPCell(this._wb, cell);
			if (!isImg) {
				// 非图片，填充文本内容
				Phrase phrase = Xls2PdfObject.parsePhrase(this._wb, cell);
				pdfpCell.setPhrase(phrase);
			}
		}
		if (isImg) {
			// 设置图片信息，图片优先，可能占用多个单元格（图片涉及的单元格无文本内容，且只会有一张图片）
			this.setImage(pdfpCell, rowIndex, colIndex);
		} else {
			// 设置文本的合并单元格
			this.setRange(pdfpCell, rowIndex, colIndex);
		}
		// 设置单元格的高度
		float height = this.getHeight(rowIndex, pdfpCell.getRowspan());
		pdfpCell.setMinimumHeight(height);
		return pdfpCell;
	}

	/**
	 * 设置文本的合并单元格
	 * 
	 * @param pdfpCell
	 * @param rowIndex
	 * @param colIndex
	 */
	private void setRange(PdfPCell pdfpCell, int rowIndex, int colIndex) {
		CellRangeAddress range = this.getCellRangeAddress(rowIndex, colIndex);
		int rowspan = 1;
		int colspan = 1;
		if (range != null) {
			rowspan = range.getLastRow() - range.getFirstRow() + 1;
			colspan = range.getLastColumn() - range.getFirstColumn() + 1;
		}
		pdfpCell.setRowspan(rowspan);
		pdfpCell.setColspan(colspan);
	}

	/**
	 * 设置图片信息，图片优先，可能占用多个单元格（图片涉及的单元格无文本内容，且只会有一张图片）
	 * 
	 * @param pdfpCell
	 * @param rowIndex
	 * @param colIndex
	 * @throws IOException
	 * @throws BadElementException
	 */
	private void setImage(PdfPCell pdfpCell, int rowIndex, int colIndex) throws IOException, BadElementException {
		for (Map.Entry<String, HSSFPictureData> entry : this._pics.entrySet()) {
			int[] arr = XlsHelper.getImgPostion(entry.getKey());
			if (arr[1] == rowIndex && arr[2] == colIndex) {
				int rowspan = arr[3] - arr[1] + 1;
				int colspan = arr[4] - arr[2] + 1;
				pdfpCell.setRowspan(rowspan);
				pdfpCell.setColspan(colspan);
				// 内边距
				pdfpCell.setPaddingLeft(arr[5] / 20.00f);
				pdfpCell.setPaddingTop(arr[6] / 32.00f);
				pdfpCell.setPaddingRight(arr[7] / 20.00f);
				pdfpCell.setPaddingBottom(arr[8] / 32.00f);
				byte[] bytes = entry.getValue().getData();
				Image image = Image.getInstance(bytes);
				pdfpCell.setImage(image);
				break;
			}
		}
	}

	/**
	 * 单元格高度
	 * 
	 * @param rowindex 单元格起始行号
	 * @param rowspan  单元格占用行数
	 * @return 高度，单位pt
	 */
	private float getHeight(int rowIndex, int rowSpan) {
		float height = 0.00f;
		for (int i = 0; i < rowSpan; i++) {
			HSSFRow row = this._sheet.getRow(rowIndex + i);
			if (row == null) {
				height += this._sheet.getDefaultRowHeightInPoints();
			} else {
				height += row.getHeightInPoints();
			}
		}
		return height;
	}

	/**
	 * 合并区域的单元格（不包括初始单元格）
	 * 
	 * @param rowIndex 行号
	 * @param colIndex 列号
	 * @return false表示该位置不是合并单元格，或者是合并区域的起始单元格
	 */
	private boolean merged(int rowIndex, int colIndex) {
		boolean isMerge = false;
		// 文本合并区域的单元格
		if (this._ranges != null && this._ranges.size() > 0) {
			int num = this._ranges.size();
			for (int i = 0; i < num; i++) {
				CellRangeAddress range = this._ranges.get(i);
				if (rowIndex > range.getFirstRow() && rowIndex <= range.getLastRow()) {
					if (colIndex >= range.getFirstColumn() && colIndex <= range.getLastColumn()) {
						isMerge = true;
					}
				}
			}
		}
		// 图片合并区域的单元格
		if (this._pics != null && this._pics.size() > 0) {
			for (Map.Entry<String, HSSFPictureData> entry : this._pics.entrySet()) {
				int[] arr = XlsHelper.getImgPostion(entry.getKey());
				if (rowIndex > arr[1] && rowIndex <= arr[3]) {
					if (colIndex >= arr[2] && colIndex <= arr[4]) {
						isMerge = true;
					}
				}
			}
		}
		return isMerge;
	}

	/**
	 * 单元格是否是图片的起始位置
	 * 
	 * @param rowIndex 行号
	 * @param colIndex 列号
	 * @return 单元格是否是图片的起始位置
	 */
	private boolean imgCell(int rowIndex, int colIndex) {
		if (this._pics == null || this._pics.size() == 0) {
			return false;
		}
		for (Map.Entry<String, HSSFPictureData> entry : this._pics.entrySet()) {
			int[] arr = XlsHelper.getImgPostion(entry.getKey());
			if (arr[1] == rowIndex && arr[2] == colIndex) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 如果单元格是文本合并区域的起始位置，返回合并区域；否则返回null
	 * 
	 * @param rowIndex 行号
	 * @param colIndex 列号
	 * @return 合并区域
	 */
	private CellRangeAddress getCellRangeAddress(int rowIndex, int colIndex) {
		if (this._ranges == null || this._ranges.size() == 0) {
			return null;
		}
		int num = this._ranges.size();
		for (int i = 0; i < num; i++) {
			CellRangeAddress range = this._ranges.get(i);
			if (range.getFirstColumn() == colIndex && range.getFirstRow() == rowIndex) {
				return range;
			}
		}
		return null;
	}

	/**
	 * sheet中最后一个单元格位置
	 * 
	 * @return 行号，列号
	 */
	private Integer[] getLastCell() {
		// 文本中最后一个单元格的位置
		Integer[] lastTextCell = this.getLastTextCell();
		// 图片中的最后一个单元格位置
		Integer[] lastImgCell = this.getLastImgCell();
		if (lastImgCell == null || lastImgCell.length == 0) {
			return lastTextCell;
		}
		Integer[] lastCell = new Integer[] { 0, 0 };
		lastCell[0] = lastTextCell[0] >= lastImgCell[0] ? lastTextCell[0] : lastImgCell[0];
		lastCell[1] = lastTextCell[1] >= lastImgCell[1] ? lastTextCell[1] : lastImgCell[1];
		return lastCell;
	}

	/**
	 * sheet中最后一个文本单元格
	 * 
	 * @return 行号，列号
	 */
	private Integer[] getLastTextCell() {
		int lastRowIndex = this._sheet.getLastRowNum();
		int lastColIndex = 0;
		for (int i = 0; i <= lastRowIndex; i++) {
			HSSFRow row = this._sheet.getRow(i);
			if (row == null) {
				continue;
			}
			// 该行最后一个单元格的索引
			int colIndex = row.getLastCellNum();
			if (colIndex > lastColIndex) {
				lastColIndex = colIndex;
			}
		}
		return new Integer[] { lastRowIndex, lastColIndex - 1 };
	}

	/**
	 * sheet的最后一个图片单元格
	 * 
	 * @return 行号，列号
	 */
	private Integer[] getLastImgCell() {
		if (this._pics == null || this._pics.size() == 0) {
			return null;
		}
		int lastRowIndex = 0;
		int lastColIndex = 0;
		for (Map.Entry<String, HSSFPictureData> entry : this._pics.entrySet()) {
			int[] arr = XlsHelper.getImgPostion(entry.getKey());
			if (arr[0] != this._sheetIndex) {
				continue;
			}
			if (arr[3] > lastRowIndex) {
				lastRowIndex = arr[3];
			}
			if (arr[4] > lastColIndex) {
				lastColIndex = arr[4];
			}
		}
		return new Integer[] { lastRowIndex, lastColIndex };
	}

}
 
 
 
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFFont;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.ss.format.CellNumberFormatter;
import org.apache.poi.ss.usermodel.BorderStyle;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.FontUnderline;
import org.apache.poi.ss.usermodel.HorizontalAlignment;
import org.apache.poi.ss.usermodel.VerticalAlignment;

import com.itextpdf.text.Anchor;
import com.itextpdf.text.BaseColor;
import com.itextpdf.text.Element;
import com.itextpdf.text.Font;
import com.itextpdf.text.FontFactory;
import com.itextpdf.text.Phrase;
import com.itextpdf.text.pdf.BaseFont;
import com.itextpdf.text.pdf.PdfPCell;

/**
 * Excel2003中的poi对象转化为itext对象
 * 
 * @author zyj
 * @date 2019-10-23
 */
public class Xls2PdfObject {
	/**
	 * HSSFCell转化为PdfPCell
	 * 
	 * @param wb
	 * @param cell
	 * @return
	 */
	public static PdfPCell parsePdfPCell(HSSFWorkbook wb, HSSFCell cell) {
		PdfPCell pdfpCell = new PdfPCell();
		HSSFCellStyle cellStyle = cell.getCellStyle();
		pdfpCell.setUseAscender(true);
		// 水平对齐方式
		HorizontalAlignment halign = cellStyle.getAlignment();
		int halign_itext = parseHorizontalAlignmen(halign);
		pdfpCell.setHorizontalAlignment(halign_itext);
		// 垂直对齐方式
		VerticalAlignment valign = cellStyle.getVerticalAlignment();
		int valign_itext = parseVerticalAlignment(valign);
		pdfpCell.setVerticalAlignment(valign_itext);
		// 填充色（背景色）
		// HSSFColor backgroundColor = cellStyle.getFillBackgroundColorColor();
		HSSFColor backgroundColor = cellStyle.getFillForegroundColorColor();
		BaseColor backgroundColor_itext = parseBackgroundColor(backgroundColor);
		pdfpCell.setBackgroundColor(backgroundColor_itext);
		// 自动换行
		boolean noWrap = !cellStyle.getWrapText();
		pdfpCell.setNoWrap(noWrap);

		// 边框颜色设置
		// 下框线
		short borderColor = cellStyle.getBottomBorderColor();
		HSSFColor color = wb.getCustomPalette().getColor(borderColor);
		BaseColor baseColor = parseColor(color);
		pdfpCell.setBorderColorBottom(baseColor);
		// 上框线
		borderColor = cellStyle.getTopBorderColor();
		baseColor = parseColor(color);
		pdfpCell.setBorderColorTop(baseColor);
		// 左框线
		borderColor = cellStyle.getLeftBorderColor();
		baseColor = parseColor(color);
		pdfpCell.setBorderColorLeft(baseColor);
		// 右框线
		borderColor = cellStyle.getRightBorderColor();
		baseColor = parseColor(color);
		pdfpCell.setBorderColorRight(baseColor);

		// 边框样式
		// 下边框
		BorderStyle borderStyle = cellStyle.getBorderBottom();
		float borderWidth = borderStyle.getCode() / 32.00f;
		pdfpCell.setBorderWidthBottom(borderWidth);
		// 上框线
		borderStyle = cellStyle.getBorderTop();
		pdfpCell.setBorderWidthTop(borderStyle.getCode() / 32.00f);
		// 左框线
		borderStyle = cellStyle.getBorderLeft();
		pdfpCell.setBorderWidthLeft(borderStyle.getCode() / 32.00f);
		// 右框线
		borderStyle = cellStyle.getBorderRight();
		pdfpCell.setBorderWidthRight(borderStyle.getCode() / 32.00f);

		pdfpCell.normalize();
		// pdfpCell.disableBorderSide(9);
		return pdfpCell;
	}

	/**
	 * HSSFCell转化为Phrase
	 * 
	 * @param wb
	 * @param cell
	 * @return
	 */
	public static Phrase parsePhrase(HSSFWorkbook wb, HSSFCell cell) {
		HSSFCellStyle cellStyle = cell.getCellStyle();
		double cellNumberValue = 0;
		boolean isNumber = cell.getCellType() == CellType.NUMERIC;
		if (cell.getCellType() == CellType.NUMERIC || cell.getCellType() == CellType.FORMULA) {
			try {
				cellNumberValue = cell.getNumericCellValue();
				isNumber = true;
			} catch (Exception e) {
				isNumber = false;
			}
		}
		int index = cellStyle.getFontIndexAsInt();
		HSSFFont xlsFont = wb.getFontAt(index);
		Font itextFont = parseFont(xlsFont);
		String formatStr = cellStyle.getDataFormatString();
		if (!"general".equals(formatStr.toLowerCase()) && isNumber) {
			String numberFormat = formatStr;
			int firstFormatIdx = formatStr.indexOf(";");
			if (firstFormatIdx > 0) {
				numberFormat = formatStr.substring(0, firstFormatIdx);
			}
			String formattedValue = new CellNumberFormatter(numberFormat).format(cellNumberValue);
			Phrase phrase = new Phrase(formattedValue, itextFont);
			return phrase;
		}
		cell.setCellType(CellType.STRING);
		String text = cell.getStringCellValue();
		Anchor anchor = new Anchor(text, itextFont);
		anchor.setName(text);
		return anchor;
	}

	/**
	 * HSSFFont转化为itext的Font
	 * 
	 * @param xlsFont HSSFFont
	 * @return Font
	 */
	public static Font parseFont(HSSFFont xlsFont) {
		// 字体名称，编码方式，，字体大小，字体样式，字体颜色
		String fontName = xlsFont.getFontName();
		// 字体编码
		String encoding = "UniGB-UCS2-H";
		// 未嵌入PDF字体
		boolean embedded = BaseFont.EMBEDDED;
		// 字体大小
		float size = xlsFont.getFontHeightInPoints();

		// Font itextFont = FontFactory.getFont(fontName, encoding, embedded, size);
		Font itextFont = FontFactory.getFont("STSong-Light", encoding, embedded, size);

		// 字体颜色
		int colorIndex = xlsFont.getColor();
		HSSFColor color = HSSFColor.getIndexHash().get(colorIndex);
		BaseColor baseColor = parseColor(color);
		itextFont.setColor(baseColor);

		// 加粗、倾斜
		boolean isItalic = xlsFont.getItalic();
		boolean isBold = xlsFont.getBold();
		if (isItalic && isBold) {
			itextFont.setStyle(Font.BOLDITALIC);
		} else if (isBold) {
			itextFont.setStyle(Font.BOLD);
		} else if (isItalic) {
			itextFont.setStyle(Font.ITALIC);
		}
		// 下划线
		FontUnderline underline = FontUnderline.valueOf(xlsFont.getUnderline());
		if (underline != FontUnderline.NONE) {
			itextFont.setStyle(Font.UNDERLINE);
		}
		return itextFont;
	}

	/**
	 * 水平对齐方式转化 - poi转化为itext
	 * 
	 * @param halign poi的水平对齐方式
	 * @return itext的水平对齐方式
	 */
	public static int parseHorizontalAlignmen(HorizontalAlignment halign) {
		int halign_itext = Element.ALIGN_LEFT;
		// 获取单元格的水平对齐方式
		switch (halign) {
		case LEFT:
			halign_itext = Element.ALIGN_LEFT;
			break;
		case CENTER:
			halign_itext = Element.ALIGN_CENTER;
			break;
		case RIGHT:
			halign_itext = Element.ALIGN_RIGHT;
			break;
		}
		return halign_itext;
	}

	/**
	 * 垂直对齐方式 转化- poi转化为itext:
	 * 
	 * @param valign poi的垂直对齐方式
	 * @return itext的垂直对齐方式
	 */
	public static int parseVerticalAlignment(VerticalAlignment valign) {
		int valign_itext = Element.ALIGN_BOTTOM;
		switch (valign) {
		case TOP:
			valign_itext = Element.ALIGN_TOP;
			break;
		case CENTER:
			valign_itext = Element.ALIGN_MIDDLE;
			break;
		case BOTTOM:
			valign_itext = Element.ALIGN_BOTTOM;
			break;
		}
		return valign_itext;
	}

	/**
	 * 颜色转化 - HSSFColor转化为BaseColor
	 * 
	 * @param color
	 * @return
	 */
	public static BaseColor parseColor(HSSFColor hssfColor) {
		if (hssfColor == null) {
			return new BaseColor(255, 255, 255);
		}
		short[] rgb = hssfColor.getTriplet();
		return new BaseColor(rgb[0], rgb[1], rgb[2]);
	}

	/**
	 * 背景颜色转化（不支持黑色背景） - HSSFColor转化为BaseColor
	 * 
	 * @param color
	 * @return
	 */
	public static BaseColor parseBackgroundColor(HSSFColor hssfColor) {
		if (hssfColor == null) {
			// 白色
			return new BaseColor(255, 255, 255);
		}
		short[] rgb = hssfColor.getTriplet();
		if (rgb[0] == 0 && rgb[1] == 0 && rgb[2] == 0) {
			rgb = new short[] { 255, 255, 255 };
		}
		return new BaseColor(rgb[0], rgb[1], rgb[2]);
	}
}
 
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import org.apache.commons.lang3.StringUtils;
import org.apache.poi.hssf.usermodel.HSSFClientAnchor;
import org.apache.poi.hssf.usermodel.HSSFPatriarch;
import org.apache.poi.hssf.usermodel.HSSFPicture;
import org.apache.poi.hssf.usermodel.HSSFPictureData;
import org.apache.poi.hssf.usermodel.HSSFShape;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;

/**
 * Excel2003的常用方法
 * 
 * @author zyj
 * @date 2019-10-14
 */
public class XlsHelper {
	/**
	 * 根据图片主键获取图片所在位置
	 * 
	 * @param key，格式： sheet索引_起始行号_起始列号_结束行号_结束列号_单元格内的左边距_上边距_右边距_下边距_uuid
	 * @return sheet索引，起始行号，起始列号，结束行号，结束列号，左边距，上边距，右边距，下边距
	 */
	public static int[] getImgPostion(String imgKey) {
		String[] arr = StringUtils.split(imgKey, "_");
		int[] position = new int[9];
		for (int i = 0; i < 9; i++) {
			position[i] = Integer.parseInt(arr[i]);
		}
		return position;
	}

	/**
	 * Excel的图片获取
	 * 
	 * @param wb Excel的工作簿
	 * @return Excel的图片，键格式：sheet索引_起始行号_起始列号_结束行号_结束列号_单元格内的左边距_上边距_右边距_下边距_uuid
	 */
	public static Map<String, HSSFPictureData> getPictrues(HSSFWorkbook wb) {
		Map<String, HSSFPictureData> map = new HashMap<String, HSSFPictureData>();
		// getAllPictures方法只能获取不同的图片，如果Excel中存在相同的图片，只能得到一张图片
		List<HSSFPictureData> pics = wb.getAllPictures();
		if (pics.size() == 0) {
			return map;
		}
		for (Integer sheetIndex = 0; sheetIndex < wb.getNumberOfSheets(); sheetIndex++) {
			HSSFSheet sheet = wb.getSheetAt(sheetIndex);
			HSSFPatriarch patriarch = sheet.getDrawingPatriarch();
			if (patriarch == null) {
				continue;
			}
			for (HSSFShape shape : patriarch.getChildren()) {
				HSSFClientAnchor anchor = (HSSFClientAnchor) shape.getAnchor();
				if (shape instanceof HSSFPicture) {
					HSSFPicture pic = (HSSFPicture) shape;
					int picIndex = pic.getPictureIndex() - 1;
					HSSFPictureData picData = pics.get(picIndex);
					// 键格式：sheet索引_行号_列号_单元格内的上边距_单元格内的左边距_uuid
					String key = sheetIndex + "_" + anchor.getRow1() + "_" + anchor.getCol1() + "_" + anchor.getRow2() + "_" + anchor.getCol2();
					key += "_" + anchor.getDx1() + "_" + anchor.getDy1() + "_" + anchor.getDx2() + "_" + anchor.getDy2();
					key += "_" + UUID.randomUUID();
					map.put(key, picData);
				}
			}
		}
		return map;
	}

	/**
	 * Excel的图片获取
	 * 
	 * @param wb         Excel的工作簿
	 * @param sheetIndex sheet索引
	 * @return Excel的图片，键格式：sheet索引_起始行号_起始列号_结束行号_结束列号_单元格内的左边距_上边距_右边距_下边距_uuid
	 */
	public static Map<String, HSSFPictureData> getPictrues(HSSFWorkbook wb, int sheetIndex) {
		Map<String, HSSFPictureData> map = new HashMap<String, HSSFPictureData>();
		// getAllPictures方法只能获取不同的图片，如果Excel中存在相同的图片，只能得到一张图片
		List<HSSFPictureData> pics = wb.getAllPictures();
		if (pics.size() == 0) {
			return map;
		}
		HSSFSheet sheet = wb.getSheetAt(sheetIndex);
		HSSFPatriarch patriarch = sheet.getDrawingPatriarch();
		if (patriarch == null) {
			return map;
		}
		for (HSSFShape shape : patriarch.getChildren()) {
			HSSFClientAnchor anchor = (HSSFClientAnchor) shape.getAnchor();
			if (shape instanceof HSSFPicture) {
				HSSFPicture pic = (HSSFPicture) shape;
				int picIndex = pic.getPictureIndex() - 1;
				HSSFPictureData picData = pics.get(picIndex);
				// 键格式：sheet索引_起始行号_起始列号_结束行号_结束列号_单元格内的左边距_上边距_右边距_下边距_uuid
				String key = sheetIndex + "_" + anchor.getRow1() + "_" + anchor.getCol1() + "_" + anchor.getRow2() + "_" + anchor.getCol2();
				key += "_" + anchor.getDx1() + "_" + anchor.getDy1() + "_" + anchor.getDx2() + "_" + anchor.getDy2();
				key += "_" + UUID.randomUUID();
				map.put(key, picData);
			}
		}
		return map;
	}
}