word03/07,ppt03/07,excel03/07,image,odt转PDF

最新推荐文章于 2024-08-06 02:15:56 发布
Catch_error
最新推荐文章于 2024-08-06 02:15:56 发布
阅读量447
点赞数 1
文章标签： word03/07 ppt03/07 excel03/07
本文链接：https://blog.youkuaiyun.com/qq_40825071/article/details/82350638
版权
本文介绍如何将Word 2003/2007、PowerPoint 2003/2007和Excel 2003/2007格式的文件转换为PDF格式，以实现更方便的阅读和分享。
摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >
//============================================================
贴别注意注意：jar包版本poi-ooxml只能用3.9/3.8，这里就有问题ppt07版，转换会报错，如果用3.10.1的poi-ooxml，07的word转换报错，目前没有更好的办法解决，各位如有好办法不吝赐教，非常感谢<dependency>
			<groupId>args4j</groupId>
			<artifactId>args4j</artifactId>
			<version>2.32</version>
		</dependency>
		<dependency>
			<groupId>org.docx4j</groupId>
			<artifactId>docx4j</artifactId>
			<version>3.2.1</version>
		</dependency>
		<dependency>
			<groupId>org.apache.poi</groupId>
			<artifactId>poi</artifactId>
			<version>3.14</version>
		</dependency>
		<dependency>
			<groupId>org.apache.poi</groupId>
			<artifactId>poi-ooxml</artifactId>
			<version>3.9</version>
		</dependency>
		<dependency>
			<groupId>org.apache.poi</groupId>
			<artifactId>poi-scratchpad</artifactId>
			<version>3.9</version>
		</dependency>
		<dependency>
			<groupId>fr.opensagres.xdocreport</groupId>
			<artifactId>org.apache.poi.xwpf.converter.pdf</artifactId>
			<version>1.0.5</version>
		</dependency>
		<dependency>
			<groupId>com.itextpdf</groupId>
			<artifactId>itextpdf</artifactId>
			<version>5.5.6</version>
		</dependency>
		<dependency>
			<groupId>fr.opensagres.xdocreport</groupId>
			<artifactId>org.odftoolkit.odfdom.converter.pdf</artifactId>
			<version>1.0.5</version>
		</dependency>
		<dependency>
			<groupId>fr.opensagres.xdocreport</groupId>
			<artifactId>fr.opensagres.xdocreport.itext.extension</artifactId>
			<version>1.0.5</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.springframework/org.springframework.core -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>org.springframework.core</artifactId>
			<version>3.2.2.RELEASE</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.8</version>
		</dependency>



<!-- excel 2007 -->
		<!-- https://mvnrepository.com/artifact/jexcelapi/jxl -->
		<dependency>
			<groupId>jexcelapi</groupId>
			<artifactId>jxl</artifactId>
			<version>2.4.2</version>
		</dependency>



		<!-- https://mvnrepository.com/artifact/com.itextpdf/itextpdf -->
		<dependency>
			<groupId>com.itextpdf</groupId>
			<artifactId>itextpdf</artifactId>
			<version>5.5.5</version>
		</dependency>
		<!-- excel 2007 -->


		<!-- https://mvnrepository.com/artifact/org.apache.poi/poi-ooxml -->
		<dependency>
			<groupId>org.apache.poi</groupId>
			<artifactId>poi-ooxml</artifactId>
			<version>3.9</version>
		</dependency>



//============================================================

package ss;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;


public abstract class Converter {


	private final String LOADING_FORMAT = "\nLoading stream\n\n";
	private final String PROCESSING_FORMAT = "Load completed in %1$dms, now converting...\n\n";
	private final String SAVING_FORMAT = "Conversion took %1$dms.\n\nTotal: %2$dms\n";

	private long startTime;
	private long startOfProcessTime;

	protected InputStream inStream;
	protected OutputStream outStream;

	protected boolean showOutputMessages = false;
	protected boolean closeStreamsWhenComplete = true;

	public Converter(InputStream inStream, OutputStream outStream, boolean showMessages, boolean closeStreamsWhenComplete){
		this.inStream = inStream;
		this.outStream = outStream;
		this.showOutputMessages = showMessages;
		this.closeStreamsWhenComplete = closeStreamsWhenComplete;
	}

	public abstract void convert() throws Exception;

	private void startTime(){
		startTime = System.currentTimeMillis();
		startOfProcessTime = startTime;
	}

	protected void loading(){
		sendToOutputOrNot(String.format(LOADING_FORMAT));
		startTime();
	}

	protected void processing(){
		long currentTime = System.currentTimeMillis();
		long prevProcessTook = currentTime - startOfProcessTime;

		sendToOutputOrNot(String.format(PROCESSING_FORMAT, prevProcessTook));

		startOfProcessTime = System.currentTimeMillis();

	}

	protected void finished(){
		long currentTime = System.currentTimeMillis();
		long timeTaken = currentTime - startTime;
		long prevProcessTook = currentTime - startOfProcessTime;

		startOfProcessTime = System.currentTimeMillis();

		if(closeStreamsWhenComplete){
			try {
				inStream.close();
				outStream.close();
			} catch (IOException e) {
				//Nothing done
			}
		}

		sendToOutputOrNot(String.format(SAVING_FORMAT, prevProcessTook, timeTaken));
	}


	private void sendToOutputOrNot(String toBePrinted){
		if(showOutputMessages){
			actuallySendToOutput(toBePrinted);
		}
	}
	
	
	protected void actuallySendToOutput(String toBePrinted){
		System.out.println(toBePrinted);
	}








}



package ss;

import java.io.*;

import org.apache.commons.lang3.StringUtils;

/**
 * Created by IntelliJ IDEA.
 * User：MUZI
 * Date: 2018/8/20
 */




public class ConverterToPDF {

    public static void tOpdfmain() throws Exception {
    	String fileUrl = "F:\\doc\\image\\";
        InputStream inStream = new FileInputStream(new File(fileUrl));
        OutputStream outStream = null;//new FileOutputStream(new File("F:\\doc\\TEST.pdf"));

        if (StringUtils.isBlank(fileUrl)) {
            throw new Exception("文件路径为空，找不到该文件");
        }
        if (fileUrl.endsWith("doc")) {
        	DocToPDFConverter docToPDFConverter  = new DocToPDFConverter(inStream, outStream, true, true) ;
            docToPDFConverter.convert();
        } else if (fileUrl.endsWith("docx")) {
        	DocxToPDFConverter docxToPDFConverter = new DocxToPDFConverter(inStream, outStream, true, true);
            docxToPDFConverter.convert();
        } else if (fileUrl.endsWith("ppt")) {
        	PptToPDFConverter pptToPDFConverter = new PptToPDFConverter(inStream , outStream , true , true);
            pptToPDFConverter.convert();
        } else if (fileUrl.endsWith("pptx")) {
        	PptxToPDFConverter pptxToPDFConverter = new PptxToPDFConverter(inStream , outStream , true , true);
            pptxToPDFConverter.convert();
            outStream = new FileOutputStream(new File("F:\\doc\\TEST.pdf"));
        } else if (fileUrl.endsWith("odt")) {
        	OdtToPDF odtToPDFConverter = new OdtToPDF(inStream, outStream, true, true);
            odtToPDFConverter.convert();
        } else if (fileUrl.endsWith("xls")) {
            //Excel03ToPdfConverter excel03ToPdfConverter = new Excel03ToPdfConverter();
            //excel03ToPdfConverter.convert(fileUrl, "");
        } else if (fileUrl.endsWith("xlsx")) {
            //Excel07ToPdfConverter excel07ToPdfConverter = new Excel07ToPdfConverter();
            //excel07ToPdfConverter.convert(fileUrl, "");
        }else if(fileUrl.endsWith(".bmp")||fileUrl.endsWith(".jpg")
        		||fileUrl.endsWith(".jpeg")||fileUrl.endsWith(".gif")
        		||fileUrl.endsWith(".png")){
        	
        	String imagesPath = "F:\\doc\\image\\";
    		String outPath = "F:\\doc\\image\\";
        	ImgToPdfConverter imgToPdfConverter = new ImgToPdfConverter();
        	
        	imgToPdfConverter.imagesToPdf(imagesPath, outPath);
        	
        }else{
            System.out.println("文件类型不支持！！！！");
        }

    }
}


package ss;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.URL;

import org.docx4j.Docx4J;
import org.docx4j.convert.in.Doc;
import org.docx4j.convert.out.FOSettings;
import org.docx4j.fonts.IdentityPlusMapper;
import org.docx4j.fonts.Mapper;
import org.docx4j.fonts.PhysicalFont;
import org.docx4j.fonts.PhysicalFonts;
import org.docx4j.jaxb.Context;
//import org.docx4j.convert.in.Doc;
//import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
import org.docx4j.wml.RFonts;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;


public class DocToPDFConverter extends Converter {

	


	public DocToPDFConverter(InputStream inStream, OutputStream outStream, boolean showMessages, boolean closeStreamsWhenComplete) {
		super(inStream, outStream, showMessages, closeStreamsWhenComplete);
	}


	
	@Override
	public void convert() throws Exception{

		loading();

		InputStream iStream = inStream;
		WordprocessingMLPackage wordMLPackage = getMLPackage(iStream);

		
		
		//设置字体
		Mapper fontMapper = new IdentityPlusMapper();
		String fontFamily = "SimSun";
		Resource fileRource = new ClassPathResource("simsun.ttc");
		
		String path = fileRource.getFile().getAbsolutePath();
		URL fontUrl = new URL("file:" + path);//
		PhysicalFonts.addPhysicalFont(fontUrl);
		PhysicalFont simsunFont = PhysicalFonts.get(fontFamily);
		fontMapper.put(fontFamily, simsunFont);
		
		RFonts rfonts = Context.getWmlObjectFactory().createRFonts(); // 设置文件默认字体
		rfonts.setAsciiTheme(null);
		rfonts.setAscii(fontFamily);
		
		wordMLPackage.getMainDocumentPart().getPropertyResolver().getDocumentDefaultRPr().setRFonts(rfonts);
		wordMLPackage.setFontMapper(fontMapper);
		
		FOSettings foSettings = Docx4J.createFOSettings();
		foSettings.setWmlPackage(wordMLPackage);
		processing();
		
		//输出pdf
		Docx4J.toFO(foSettings, outStream, Docx4J.FLAG_EXPORT_PREFER_XSL);

		/*processing();
		Docx4J.toPDF(wordMLPackage, outStream);*/

		finished();
		
	}

	protected WordprocessingMLPackage getMLPackage(InputStream iStream) throws Exception{
		PrintStream originalStdout = System.out;
		
		//Disable stdout temporarily as Doc convert produces alot of output
		System.setOut(new PrintStream(new OutputStream() {
			public void write(int b) {
				//DO NOTHING
			}
		}));

		WordprocessingMLPackage mlPackage = Doc.convert(iStream);
		
		System.setOut(originalStdout);
		return mlPackage;
	}

}



package ss;

import java.awt.Color;
import java.io.InputStream;
import java.io.OutputStream;

import org.apache.poi.xwpf.converter.pdf.PdfConverter;
import org.apache.poi.xwpf.converter.pdf.PdfOptions;
import org.apache.poi.xwpf.usermodel.XWPFDocument;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

import com.lowagie.text.Font;
import com.lowagie.text.pdf.BaseFont;

import fr.opensagres.xdocreport.itext.extension.font.ITextFontRegistry;

public class DocxToPDFConverter extends Converter {

	public DocxToPDFConverter(InputStream inStream, OutputStream outStream, boolean showMessages,

			boolean closeStreamsWhenComplete) {

		super(inStream, outStream, showMessages, closeStreamsWhenComplete);

	}

	
	@Override

	public void convert() throws Exception {

		loading();
		PdfOptions options = PdfOptions.create();
		XWPFDocument document = new XWPFDocument(inStream);
		// 支持中文字体
		options.fontProvider(new ITextFontRegistry() {
			public Font getFont(String familyName, String encoding, float size, int style, Color color) {
				
				try {
					Resource fileRource = new ClassPathResource("simsun.ttf");
					String path = fileRource.getFile().getAbsolutePath();
					BaseFont bfChinese = BaseFont.createFont(path, BaseFont.IDENTITY_H, BaseFont.EMBEDDED);
					Font fontChinese = new Font(bfChinese, size, style, color);
					if (familyName != null)
						fontChinese.setFamily(familyName);
					return fontChinese;

				} catch (Throwable e) {
					e.printStackTrace();
					return ITextFontRegistry.getRegistry().getFont(familyName, encoding, size, style, color);
				}

			}

		});

		processing();
		PdfConverter.getInstance().convert(document, outStream, options);
		finished();

	}

}



package ss;

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

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

import javax.imageio.ImageIO;

public class ImgToPdfConverter {


	public static  void imagesToPdf(String imagesPath , String desc) {
		
		/*File tempFile =new File( desc.trim());  
		  
	    String fileName = tempFile.getName();
		fileName = imagesPath + fileName + ".pdf";
		
		
		
		
		File file = new File(fileName);*/
		
		try {
			File tempFile =new File( desc.trim());  
			  
		    String fileName = tempFile.getName();
			fileName = imagesPath + fileName + ".pdf";
            File file = new File(fileName);
            // 第一步：创建一个document对象。
            Document document = new Document();
            document.setMargins(0, 0, 0, 0);
            // 第二步：
            // 创建一个PdfWriter实例，
            PdfWriter.getInstance(document, new FileOutputStream(file));
            // 第三步：打开文档。
            document.open();
            // 第四步：在文档中增加图片。
            File files = new File(imagesPath);
            String[] images = files.list();
            int len = images.length;

            for (int i = 0; i < len; i++)
            {
                if (images[i].toLowerCase().endsWith(".bmp")
                        || images[i].toLowerCase().endsWith(".jpg")
                        || images[i].toLowerCase().endsWith(".jpeg")
                        || images[i].toLowerCase().endsWith(".gif")
                        || images[i].toLowerCase().endsWith(".png")) {
                    String temp = imagesPath + "\\" + images[i];
                    Image img = Image.getInstance(temp);
                    img.setAlignment(Image.ALIGN_CENTER);
                    // 根据图片大小设置页面，一定要先设置页面，再newPage（），否则无效
                    document.setPageSize(new Rectangle(img.getWidth(), img.getHeight()));
                    document.newPage();
                    document.add(img);
                }
            }
            // 第五步：关闭文档。
            document.close();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
	

	public static void main(String[] args) {
		String imagesPath = "F:\\doc\\image\\";
		String desc = "F:\\doc\\image\\";
		imagesToPdf(imagesPath, imagesPath);
		System.out.println("======ok=====");
	}

}



package ss;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import org.kohsuke.args4j.CmdLineException;
import org.kohsuke.args4j.CmdLineParser;
import org.kohsuke.args4j.Option;



public class MainClass{


	public static final String VERSION_STRING = "\nDocs to PDF Converter Version 1.7 (8 Dec 2013)\n\nThe MIT License (MIT)\nCopyright (c) 2013-2014 Yeo Kheng Meng";
	public enum DOC_TYPE {
		DOC,
		DOCX,
		PPT,
		PPTX,
		ODT
	}
	
	
	public static void main(String[] args){
		Converter converter;

		try{
			converter = processArguments(args);
		} catch (Exception e){
			System.out.println("\n\nInput\\Output file not specified properly.");
			return;
		}


		if(converter == null){
			System.out.println("Unable to determine type of input file.");
		} else {
			try {
				converter.convert();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

	}


	public static Converter processArguments(String[] args) throws Exception{
		CommandLineValues values = new CommandLineValues();
		CmdLineParser parser = new CmdLineParser(values);

		Converter converter = null;
		try {
			parser.parseArgument(args);

			boolean version = values.version;

			if(version){
				System.out.println(VERSION_STRING);
				System.exit(0);
			}


			String inPath = values.inFilePath;
			String outPath = values.outFilePath;
			boolean shouldShowMessages = values.verbose;


			if(inPath == null){
				parser.printUsage(System.err);
				throw new IllegalArgumentException();
			}

			if(outPath == null){
				outPath = changeExtensionToPDF(inPath);
			}


			String lowerCaseInPath = inPath.toLowerCase();
			
			InputStream inStream = getInFileStream(inPath);
			OutputStream outStream = getOutFileStream(outPath);
			
			if(values.type == null){
				if(lowerCaseInPath.endsWith("doc")){
					converter = new DocToPDFConverter(inStream, outStream, shouldShowMessages, true);
				} else if (lowerCaseInPath.endsWith("docx")){
					converter = new DocxToPDFConverter(inStream, outStream, shouldShowMessages, true);
				} else if(lowerCaseInPath.endsWith("ppt")){
					converter = new PptToPDFConverter(inStream, outStream, shouldShowMessages, true);
				} else if(lowerCaseInPath.endsWith("pptx")){
					converter = new PptxToPDFConverter(inStream, outStream, shouldShowMessages, true);
				} else if(lowerCaseInPath.endsWith("odt")){
					converter = new OdtToPDF(inStream, outStream, shouldShowMessages, true);
				} else {
					converter = null;
				}


			} else {

				switch(values.type){
				case DOC: converter = new DocToPDFConverter(inStream, outStream, shouldShowMessages, true);
				break; 
				case DOCX: converter = new DocxToPDFConverter(inStream, outStream, shouldShowMessages, true);
				break;
				case PPT:  converter = new PptToPDFConverter(inStream, outStream, shouldShowMessages, true);
				break;
				case PPTX: converter = new PptxToPDFConverter(inStream, outStream, shouldShowMessages, true);
				break;
				case ODT: converter = new OdtToPDF(inStream, outStream, shouldShowMessages, true);
				break;
				default: converter = null;
				break;

				}


			}
			
		} catch (CmdLineException e) {
			// handling of wrong arguments
			System.err.println(e.getMessage());
			parser.printUsage(System.err);
		}

		return converter;

	}


	public static class CommandLineValues {

		@Option(name = "-type", aliases = "-t", required = false, usage = "Specifies doc converter. Leave blank to let program decide by input extension.")
		public DOC_TYPE type = null;


		@Option(name = "-inputPath", aliases = {"-i", "-in", "-input"}, required = false,  metaVar = "<path>",
				usage = "Specifies a path for the input file.")
		public String inFilePath = null;


		@Option(name = "-outputPath", aliases = {"-o", "-out", "-output"}, required = false, metaVar = "<path>",
				usage = "Specifies a path for the output PDF.")
		public String outFilePath = null;

		@Option(name = "-verbose", aliases = {"-v"}, required = false, usage = "To see intermediate processing messages.")
		public boolean verbose = false;

		@Option(name = "-version", aliases = {"-ver"}, required = false, usage = "To view version code.")
		public boolean version = false;


	}

	//From http://stackoverflow.com/questions/941272/how-do-i-trim-a-file-extension-from-a-string-in-java
	public static String changeExtensionToPDF(String originalPath) {

//		String separator = System.getProperty("file.separator");
		String filename = originalPath;

//		// Remove the path upto the filename.
//		int lastSeparatorIndex = originalPath.lastIndexOf(separator);
//		if (lastSeparatorIndex == -1) {
//			filename = originalPath;
//		} else {
//			filename = originalPath.substring(lastSeparatorIndex + 1);
//		}

		// Remove the extension.
		int extensionIndex = filename.lastIndexOf(".");

		String removedExtension;
		if (extensionIndex == -1){
			removedExtension =  filename;
		} else {
			removedExtension =  filename.substring(0, extensionIndex);
		}
		String addPDFExtension = removedExtension + ".pdf";

		return addPDFExtension;
	}
	
	
	protected static InputStream getInFileStream(String inputFilePath) throws FileNotFoundException{
		File inFile = new File(inputFilePath);
		FileInputStream iStream = new FileInputStream(inFile);
		return iStream;
	}
	
	protected static OutputStream getOutFileStream(String outputFilePath) throws IOException{
		File outFile = new File(outputFilePath);
		
		try{
			//Make all directories up to specified
			outFile.getParentFile().mkdirs();
		} catch (NullPointerException e){
			//Ignore error since it means not parent directories
		}
		
		outFile.createNewFile();
		FileOutputStream oStream = new FileOutputStream(outFile);
		return oStream;
	}











}




package ss;

import java.io.InputStream;
import java.io.OutputStream;

import org.odftoolkit.odfdom.converter.pdf.PdfConverter;
import org.odftoolkit.odfdom.converter.pdf.PdfOptions;
import org.odftoolkit.odfdom.doc.OdfTextDocument;


public class OdtToPDF extends Converter {

	public OdtToPDF(InputStream inStream, OutputStream outStream, boolean showMessages, boolean closeStreamsWhenComplete) {
		super(inStream, outStream, showMessages, closeStreamsWhenComplete);
	}


	@Override
	public void convert() throws Exception {
		loading();       


		OdfTextDocument document = OdfTextDocument.loadDocument(inStream);

		PdfOptions options = PdfOptions.create();

		
		processing();
		PdfConverter.getInstance().convert(document, outStream, options);

		finished();

		

	}

}



package ss;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics2D;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import org.apache.poi.hslf.model.Slide;
import org.apache.poi.hslf.usermodel.SlideShow;

public class PptToPDFConverter extends PptxToPDFConverter {

	private Slide[] slides;
	
	public PptToPDFConverter(InputStream inStream, OutputStream outStream, boolean showMessages, boolean closeStreamsWhenComplete) {
		super(inStream, outStream, showMessages, closeStreamsWhenComplete);
	}


	@Override	
	protected Dimension processSlides() throws IOException{

		SlideShow ppt = new SlideShow(inStream);
		Dimension dimension = ppt.getPageSize();
		slides = ppt.getSlides();
		return dimension;
	}

	
	@Override
	protected int getNumSlides(){
		return slides.length;
	}
	
	@Override
	protected void drawOntoThisGraphic(int index, Graphics2D graphics){
		slides[index].draw(graphics);
	}
	
	@Override
	protected Color getSlideBGColor(int index){
		return slides[index].getBackground().getFill().getForegroundColor();
	}

}




package ss;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics2D;
import java.awt.geom.AffineTransform;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import org.apache.poi.xslf.usermodel.XMLSlideShow;
import org.apache.poi.xslf.usermodel.XSLFSlide;

import com.itextpdf.text.Document;
import com.itextpdf.text.Image;
import com.itextpdf.text.Rectangle;
import com.itextpdf.text.pdf.PdfWriter;


public class PptxToPDFConverter extends Converter{

	

	public PptxToPDFConverter(InputStream inStream, OutputStream outStream, boolean showMessages, boolean closeStreamsWhenComplete) {
		super(inStream, outStream, showMessages, closeStreamsWhenComplete);
	}


	private XSLFSlide[] slides;
	

	@Override
	public void convert() throws Exception {
		loading();
		

		

		Dimension pgsize = processSlides();
		
		processing();
		
	    double zoom = 2; // magnify it by 2 as typical slides are low res
	    AffineTransform at = new AffineTransform();
	    at.setToScale(zoom, zoom);

		
		Document document = new Document();

		PdfWriter writer = PdfWriter.getInstance(document, outStream);
		document.open();
		
		for (int i = 0; i < getNumSlides(); i++) {

			BufferedImage bufImg = new BufferedImage((int)Math.ceil(pgsize.width*zoom), (int)Math.ceil(pgsize.height*zoom), BufferedImage.TYPE_INT_RGB);
			Graphics2D graphics = bufImg.createGraphics();
			graphics.setTransform(at);
			//clear the drawing area
			graphics.setPaint(getSlideBGColor(i));
			graphics.fill(new Rectangle2D.Float(0, 0, pgsize.width, pgsize.height));
			try{
				drawOntoThisGraphic(i, graphics);
			} catch(Exception e){
				//Just ignore, draw what I have
			}
			
			Image image = Image.getInstance(bufImg, null);
			document.setPageSize(new Rectangle(image.getScaledWidth(), image.getScaledHeight()));
			document.newPage();
			image.setAbsolutePosition(0, 0);
			document.add(image);
		}
		//Seems like I must close document if not output stream is not complete
		document.close();
		
		//Not sure what repercussions are there for closing a writer but just do it.
		writer.close();
		finished();
		

	}
	
	protected Dimension processSlides() throws IOException{
		InputStream iStream = inStream;
		XMLSlideShow ppt = new XMLSlideShow(iStream);
		Dimension dimension = ppt.getPageSize();
		slides = ppt.getSlides();
		return dimension;
	}
	
	protected int getNumSlides(){
		return slides.length;
	}
	
	
	protected void drawOntoThisGraphic(int index, Graphics2D graphics){
		slides[index].draw(graphics);
	}
	
	protected Color getSlideBGColor(int index){
		return slides[index].getBackground().getFillColor();
	}
	
	
	
	




}



package exceltopdf;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;


import com.itextpdf.text.Document;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.Element;
import com.itextpdf.text.Font;
import com.itextpdf.text.PageSize;
import com.itextpdf.text.Paragraph;
import com.itextpdf.text.pdf.BaseFont;
import com.itextpdf.text.pdf.PdfPCell;
import com.itextpdf.text.pdf.PdfPTable;
import com.itextpdf.text.pdf.PdfWriter;

import jxl.Cell;
import jxl.Range;
import jxl.Sheet;
import jxl.Workbook;
import jxl.read.biff.BiffException;

public class Excel2Pdf03 {
	public static void main(String[] args) throws DocumentException, IOException {
		Document document = new Document(PageSize.A4, 0, 0, 50, 0);
		document.open();
		PdfWriter writer = PdfWriter.getInstance(document, new FileOutputStream("F:\\doc\\666.pdf" , true));

		// 字体设置
		/*
		 * 由于itext不支持中文，所以需要进行字体的设置，我这里让itext调用windows系统的中文字体，
		 * 找到文件后，打开属性，将文件名及所在路径作为字体名即可。
		 */
		// 创建BaseFont对象，指明字体，编码方式,是否嵌入
		BaseFont bf = BaseFont.createFont("simsun.ttf", BaseFont.IDENTITY_H, false);
		// 创建Font对象，将基础字体对象，字体大小，字体风格
		Font font = new Font(bf, 13, Font.NORMAL);
		int rowNum = 0;
		int colNum = 0;
		Workbook workbook =null;
		
		try {
			
			
			workbook = Workbook.getWorkbook(new File("F:\\doc\\TEST_EXCEL.xls"));
			document.open();
			
			for(int k = 0; k < workbook.getNumberOfSheets(); k++ ) {
				Sheet sheet =  workbook.getSheet(k);//k=0表示去第一张表格；k=1表示取第二个表格
				int column = sheet.getColumns();
				// 下面是找出表格中的空行和空列
				List<Integer> nullCol = new ArrayList<>();
				List<Integer> nullRow = new ArrayList<>();
				for (int j = 0; j < sheet.getColumns(); j++) {
					int nullColNum = 0;
					for (int i = 0; i < sheet.getRows(); i++) {
						Cell cell = sheet.getCell(j, i);
						String str = cell.getContents();
						System.out.println("str= " + str);
						if (str == null || "".equals(str)) {
							nullColNum++;
						}
					}
					if (nullColNum == sheet.getRows()) {
						System.out.println("nullColNum= " + nullColNum + "; sheet.getRows()=" + sheet.getRows());
						System.out.println("j=" + j);
						nullCol.add(j);
						column--;
					}
				}

				
				/*nullCol = new ArrayList<>();
				nullRow = new ArrayList<>();*/
				
				//合并单元格
				PdfPTable table = new PdfPTable(column);
				
				Range[] ranges = sheet.getMergedCells();

				PdfPCell cell1 = new PdfPCell();
				for (int i = 0; i < sheet.getRows(); i++) {
					if (nullRow.contains(i)) { // 如果这一行是空行，这跳过这一行
						continue;
					}
					for (int j = 0; j < sheet.getColumns(); j++) {
						if (nullCol.contains(j)) { // 如果这一列是空列，则跳过这一列
							continue;
						}
						boolean flag = true;
						Cell cell = sheet.getCell(j, i);
						String str = cell.getContents();
						for (Range range : ranges) { // 合并的单元格判断和处理
							if (isMearge(i, j, range)) {
								if (str == null || "".equals(str)) {
									flag = false;
									break;
								}
								rowNum = range.getBottomRight().getRow() - range.getTopLeft().getRow() + 1;
								System.out.println("range.getBottomRight().getRow()   --  " + range.getBottomRight().getRow() + "   ====   " + range.getTopLeft().getRow());
								colNum = range.getBottomRight().getColumn() - range.getTopLeft().getColumn() + 1;
								if (rowNum > colNum) {
									cell1 = mergeRow(str, font, rowNum);
									cell1.setColspan(colNum);
									table.addCell(cell1);
								} else {
									cell1 = mergeCol(str, font, colNum);
									cell1.setRowspan(rowNum);
									table.addCell(cell1);
								}
								// System.out.println(num1 + " " + num2);
								flag = false;
								break;
							}
							
							
						}
						if (flag) {
							table.addCell(getPDFCell(str, font));
						}
					}
				}
				document.add(table);	
				System.out.println("========TOPDF====OK=======");
			}
			
			
			
		} catch (BiffException | IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			workbook.close();
			document.close();
			writer.close();
			
		}
	}
	
	private static boolean isMearge(int i, int j , Range range) {
		return j >= range.getTopLeft().getColumn() && j <= range.getBottomRight().getColumn()
				&& i >= range.getTopLeft().getRow() && i <= range.getBottomRight().getRow();
	}
	
	

	// 合并行的静态函数
	public static PdfPCell mergeRow(String str, Font font, int i) {

		// 创建单元格对象，将内容及字体传入
		PdfPCell cell = new PdfPCell(new Paragraph(str, font));
		// 设置单元格内容居中
		cell.setHorizontalAlignment(Element.ALIGN_CENTER);
		cell.setVerticalAlignment(Element.ALIGN_MIDDLE);
		// 将该单元格所在列包括该单元格在内的i行单元格合并为一个单元格
		cell.setRowspan(i);

		return cell;
	}

	// 合并列的静态函数
	public static PdfPCell mergeCol(String str, Font font, int i) {

		PdfPCell cell = new PdfPCell(new Paragraph(str, font));
		cell.setMinimumHeight(25);
		cell.setHorizontalAlignment(Element.ALIGN_CENTER);
		cell.setVerticalAlignment(Element.ALIGN_MIDDLE);
		// 将该单元格所在行包括该单元格在内的i列单元格合并为一个单元格
		cell.setColspan(i);

		return cell;
	}

	// 获取指定内容与字体的单元格
	public static PdfPCell getPDFCell(String string, Font font) {
		// 创建单元格对象，将内容与字体放入段落中作为单元格内容
		PdfPCell cell = new PdfPCell(new Paragraph(string, font));

		cell.setHorizontalAlignment(Element.ALIGN_CENTER);
		cell.setVerticalAlignment(Element.ALIGN_MIDDLE);

		// 设置最小单元格高度
		cell.setMinimumHeight(25);
		return cell;
	}
}



package ggg;

import java.io.*;

import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import com.itextpdf.text.*;
import com.itextpdf.text.Font;
import com.itextpdf.text.pdf.*;

public class EXCEL07 {
	public static void main(String[] args) throws Exception {

		BaseFont bf = BaseFont.createFont("simsun.ttf", BaseFont.IDENTITY_H, false);
		Font font = new Font(bf, 13, Font.NORMAL);
		Document document = new Document(PageSize.A4, 0, 0, 50, 0);
		PdfWriter.getInstance(document, new FileOutputStream("f:\\doc\\2222222.pdf", true));
		document.open();

		FileInputStream input = new FileInputStream(new File("F:\\doc\\222.xlsx"));
		XSSFWorkbook xssfWorkbook = new XSSFWorkbook(input);
		int maxCellNum = 0;
		for (int k = 0; k < xssfWorkbook.getNumberOfSheets(); k++) {
			XSSFSheet my_worksheet = xssfWorkbook.getSheetAt(k);
			
			for (int m = 0; m < my_worksheet.getLastRowNum(); m++) {
				int widthlength = my_worksheet.getRow(m).getLastCellNum();
				System.out.println("my_worksheet.getLastRowNum()=" + my_worksheet.getLastRowNum() + "widthlength=" + widthlength);
				if(maxCellNum < widthlength) {
					maxCellNum = widthlength;
				}
			}
			
			PdfPTable my_table = new PdfPTable(maxCellNum);
			PdfPCell table_cell;
			for (int i = 0; i <= my_worksheet.getLastRowNum(); i++) {
				Row row = my_worksheet.getRow(i);
				for (int j = 0; j < maxCellNum; j++) {
					Cell cell = row.getCell(j);
					
					String cellValue = dealCell(cell);
					
				
					//===============
					if (null == cellValue) {
						table_cell = new PdfPCell(new Paragraph(""));
					} else {
						table_cell = new PdfPCell(new Paragraph(cellValue, font));

					}
					my_table.addCell(table_cell);
				}
			}
			// Finally add the table to PDF document
			document.add(my_table);

		}
		document.close();
		// we created our pdf file..
		input.close(); 

		System.out.println("===========ok===========");
	}

	// 合并行的静态函数
	public static PdfPCell mergeRow(String str, Font font, int i) {

		// 创建单元格对象，将内容及字体传入
		PdfPCell cell = new PdfPCell(new Paragraph(str, font));
		// 设置单元格内容居中
		cell.setHorizontalAlignment(Element.ALIGN_CENTER);
		cell.setVerticalAlignment(Element.ALIGN_MIDDLE);
		// 将该单元格所在列包括该单元格在内的i行单元格合并为一个单元格
		cell.setRowspan(i);

		return cell;
	}

	// 合并列的静态函数
	public static PdfPCell mergeCol(String str, Font font, int i) {

		PdfPCell cell = new PdfPCell(new Paragraph(str, font));
		cell.setMinimumHeight(25);
		cell.setHorizontalAlignment(Element.ALIGN_CENTER);
		cell.setVerticalAlignment(Element.ALIGN_MIDDLE);
		// 将该单元格所在行包括该单元格在内的i列单元格合并为一个单元格
		cell.setColspan(i);

		return cell;
	}

	// 获取指定内容与字体的单元格
	public static PdfPCell getPDFCell(String string, Font font) {
		// 创建单元格对象，将内容与字体放入段落中作为单元格内容
		PdfPCell cell = new PdfPCell(new Paragraph(string, font));

		cell.setHorizontalAlignment(Element.ALIGN_CENTER);
		cell.setVerticalAlignment(Element.ALIGN_MIDDLE);

		// 设置最小单元格高度
		cell.setMinimumHeight(25);
		return cell;
	}
	
	
	//处理单元格的值
	public static String dealCell(Cell cell) {
		String cellValue = null;
        if (null != cell) {
            switch (cell.getCellType()) { // 判断excel单元格内容的格式，并对其进行转换，以便插入数据库
            case 0:
                cellValue = String.valueOf((int) cell.getNumericCellValue());
                break;
            case 1:
                cellValue = cell.getStringCellValue();
                break;
            case 2:
                cellValue = cell.getNumericCellValue() + "";
                //cellValue = String.valueOf(cell.getDateCellValue());
                break;
            case 3:
                cellValue = "";
                break;
            case 4:
                cellValue = String.valueOf(cell.getBooleanCellValue());
                break;
            case 5:
                cellValue = String.valueOf(cell.getErrorCellValue());
                break;
            }
        } 
		return cellValue;
	}

}