JAVA項目實戰-實現生成固定格式PDF文件和打包成zip壓縮包並在瀏覽器中輸出

1.工具 

 // 生成PDF自定義模板內容

 (1) Adobe Acrobat Pro9 

 

2.操作步驟

 (1)利用Adobe Acrobat Pro9 生成一張根據業務場景的PDF,設置每個內容的字段(這款軟件功能比較強大，可以設置條形碼和二維碼的參數) 

 

(3)JAVA實現代碼

 

import com.itextpdf.text.pdf.PdfReader;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.util.ClassUtils;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ResourceUtils;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.util.HashMap;
import java.util.List;
import java.util.UUID;

/**
 * @description: PDF下載
 * @author: ZhuCJ 
 * @date: 2020-05-20 15:36
 */
@Slf4j
@Component
public class PdfDownUtils {

    /** 最終存放pdf位置 */
    @Value("${pdf.savePath}")
    private String savePath;

    /** 讀取模板,生成的復制pdf位置 */
    @Value("${pdf.cachePath}")
    private String cacheTempPath;

    /**讀取模板的位置 */
    @Value("${pdf.tempPath}")
    private String tempPath;

    /**
     * 讀取的模板名字
     */
    public static String TEMPLATE_NAME = "temp.pdf";

    
    /**
     * 下載單張PDF
     * @param mapPDF
     * @param fileName
     * @param filePath
     * @param response
     * @throws IOException
     */
    public void pdfCompress(HashMap<String,String> mapPDF,String fileName
                         ,String filePath, HttpServletResponse response) throws IOException{

        String sysPath = ClassUtils.getDefaultClassLoader().getResource("").getPath();
        //項目下模板路徑
        //String  readTempPath = sysPath +"data"+File.separator+"hanzt"+File.separator+"temp";
        //讀取模板文件
        PdfReader reader = new PdfReader(tempPath + File.separator + TEMPLATE_NAME);
        //生成pdf
        InputStream  pdfStream = null;
        try {
           pdfStream  = this.print(reader, mapPDF,fileName,filePath);
        } catch (IOException e) {
            e.printStackTrace();
        }
        ServletOutputStream op = null;
        try {
            op = response.getOutputStream();
        } catch (IOException e) {
            e.printStackTrace();
        }
        response.setContentType("application/pdf");
        response.setHeader("Content-Disposition", "inline; filename=\""
                + new String(fileName.getBytes("gb18030"), "ISO8859-1") + ".pdf" + "\"");
        int length = 0;
        byte[] bytes = new byte[1024];
        while((pdfStream != null) && ((length = pdfStream.read(bytes)) != -1)) {
            op.write(bytes, 0, length);
        }
        op.close();
        reader.close();
        response.flushBuffer();
    }



    /**
     * 生成pdf打成ZIP包下載
     * @param orderZips 模板參數
     * @param filePath   pdf 保存文件上級文件夾名
     * @param response
     * @throws IOException
     */
    public void pdfCompressZip(List<List<HashMap<String,Object>>> orderZips,
                               String filePath, HttpServletResponse response) throws IOException{
        if (CollectionUtils.isEmpty(orderZips)){
            return;
        }

        for (List orderZip:orderZips){
            if (CollectionUtils.isEmpty(orderZip)){
                continue;
            }
          for (Object orderPdf:orderZip){
              HashMap<String,Object> mapPDF =(HashMap<String,Object>) orderPdf;
              //獲取生成pdf的文件名
              String fileName = null;
              if (mapPDF.containsKey("fileName")){
                  fileName = mapPDF.get("fileName").toString();
              }else {
                  //默認隨機生成一個,保證唯一性避免覆蓋
                  fileName = UUID.randomUUID().toString();
              }
              try {
                  this.printFilePath(mapPDF, fileName, filePath);
              } catch (IOException e) {
                  log.error("生成Pdf文件IO異常:{}",e.getMessage());
              }
          }
        }
        //本次操作保存pdf文件路徑,用於壓縮成Zip包
        String pdfFilePath = savePath+File.separator+filePath+File.separator;
        log.info("待壓縮zip包文件名:{}",pdfFilePath);
        File file = new File(pdfFilePath);
        String zipFile = null;
        File ftp = null;
        try {
            zipFile = CompressZipUtil.zipFile(file,"zip");
        } catch (Exception e) {
            e.printStackTrace();
        }
        response.setContentType("APPLICATION/OCTET-STREAM");
        response.setHeader("Content-Disposition","attachment; filename=listDown.zip");
        OutputStream out = null;
        InputStream in  = null;
        try {
            out = response.getOutputStream();
            //
            ftp = ResourceUtils.getFile(zipFile);
            in = new FileInputStream(ftp);
            // 循環取出流中的數據
            byte[] b = new byte[100];
            int len;
            while ((len = in.read(b)) !=-1) {
                out.write(b, 0, len);
            }
        } catch (Exception e) {
            e.printStackTrace();
            log.error("文件讀取異常:{}",e.getMessage());

        }finally {
            if (in !=null){
                in.close();
            }
            if (out !=null){
                out.close();
            }
            log.info("zip下載完成,進行刪除本地zip包");
            //刪除保存的Pdf文件
            DeleteFileUtil.deleteFile(file);
            //刪除保存的壓縮包
            if (ftp!=null){
                ftp.delete();
            }
        }
    }

    /**
     *
     * @param map
     * @param fileName
     * @return 所在文件地址
     * @throws IOException
     */
    private String printFilePath(HashMap<String,Object> map
            ,String fileName,String filePath) throws IOException {
        String sysPath = ClassUtils.getDefaultClassLoader().getResource("").getPath();
        //項目下模板路徑
       // String  readTempPath = sysPath +"data"+File.separator+"hanzt"+File.separator+"temp";
        //判斷是否存在文件目錄，不存在創建
        createFile(savePath,cacheTempPath);
        //保存路徑+隨機文件名
        String save = savePath+ File.separator+filePath+File.separator;
        PdfFormater pdf = new PdfFormater(tempPath, save,cacheTempPath,TEMPLATE_NAME,map);
        pdf.doTransform(fileName);
        return save;
    }


        /**
          * 打印，以PDF為模板
          * @param templateName String 模板名字
          * @param map 模板數據HashMap
          * @return InputStream
          * @throws IOException
          */
    private InputStream print(PdfReader reader, HashMap<String,String> map, String fileName, String filePath) throws IOException {
        InputStream is = null;
        String sysPath = ClassUtils.getDefaultClassLoader().getResource("").getPath();
        //項目下模板路徑
        //String  readTempPath = sysPath +"data"+File.separator+"hanzt"+File.separator+"temp";
        //判斷是否存在文件目錄，不存在創建
        createFile(savePath,cacheTempPath);
        //保存路徑+隨機文件名
        String save = savePath+ File.separator+filePath+File.separator;
        PdfFormater pdf = new PdfFormater(tempPath,save,cacheTempPath,TEMPLATE_NAME, map);
        String PdfFilePath = pdf.doTransform(fileName);
        is = new FileInputStream(PdfFilePath);
        return is;
    }



    /**
     * 判斷文件夾是否存在，不存在創建一個
     * @param filePaths
     * @return
     */
    public void createFile(String ... filePaths){
        for (String filePath:filePaths){
            File file = new File(filePath);
            if (!file.exists()){
                file.mkdirs();
            }
        }
    }

}

import com.itextpdf.text.BadElementException;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.Image;
import com.itextpdf.text.Rectangle;
import com.itextpdf.text.pdf.*;
import com.sf.vsolution.hb.sfce.util.string.StringUtils;
import lombok.extern.slf4j.Slf4j;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;

/**
 * @description:
 * @author: ZhuCJ 
 * @date: 2020-05-27 10:50
 */
@Slf4j
public class PdfFormater {
    /**
     * pdf模板路徑
     */
    private String templatePath;
    /**
     * 下載完成的pdf路徑
     */
    private String savePath;
    /**
     * 緩存pdf路徑
     */
    private String cachePath;

    /**
     * 讀取模板對象
     */
    private String templateName;

    /**
     * 需要填充的數據
     */
    private Map dataMap;

    private String cacheFileName;

    //新的PDF文件名稱
    private String resultFileName;
    //動態數據
    private List dynData;


    /**
          * 構造器，生成PDF引擎實例，並引入相應模板文件XXX.FO、路徑和報表數據HashMap
          *
          * @param templateDir
          *            模板文件所在目錄
          * @param basePath
          *            模板文件工作副本及結果PDF文件所在工作目錄
          * @param templateFileFo
          *            模板文件名，推薦格式為“XXXTemplate.FO”， 其文件由word模板文檔在設計時轉換而成
          * @param dataMap
          *            對應模板的數據HashMap，由調用該打印引擎的里程根據模板格式和約定進行准備
          */
    public PdfFormater(String templatePath, String savePath, String cachePath,
                       String templateName, Map dataMap) {
        this.templatePath = templatePath;
        this.savePath = savePath;
        this.templateName = templateName;
        this.cachePath = cachePath;
        this.dataMap = dataMap;
    }

    /**
     * 設置字體
     * @param font
     * @return
     */
    private BaseFont getBaseFont(String font) {
      // 需要根據不同的模板返回字體
        BaseFont bf = null;
        try {
            bf = BaseFont.createFont( StringUtils.isEmpty(font)?"STSong-Light":font, "UniGB-UCS2-H",BaseFont.NOT_EMBEDDED);
        } catch (DocumentException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bf;
    }

    /**
     * 避免出現多線程重復讀
     * @param fileName
     * @return
     */
    public String doTransform(String fileName) {
        long name = System.currentTimeMillis();
        //緩存模板名字
        cacheFileName =   name + ".pdf";
        //最后保存模板名字
        resultFileName =  fileName + ".pdf";
        try {
            PdfReader reader;
            PdfStamper stamper;
            //讀取PDF模板對象
            reader = new PdfReader(templatePath + File.separator + templateName);
            //生成新的PDF模板對象
            stamper = new PdfStamper(reader, new FileOutputStream(cachePath + File.separator + cacheFileName));
            AcroFields form = stamper.getAcroFields();
            form.addSubstitutionFont(getBaseFont(""));
            transformRegular(form,stamper);
            stamper.setFormFlattening(true);
            stamper.close();
            reader.close();
            postProcess();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return savePath + File.separator + resultFileName;
    }

         /**
          * 填充規整的表單域
          * @param form
          */
    private void transformRegular(AcroFields form,PdfStamper stamper) {
        if (dataMap == null || dataMap.size() == 0) {return;}
        String key = "";
        Iterator ekey = dataMap.keySet().iterator();
        Object obj = null ;
        while (ekey.hasNext()) {
            key = ekey.next().toString();
            try {
                obj = dataMap.get(key);
                if(obj instanceof List){
                   //map中放的是list，為動態字段
                    dynData = (List)obj;
                    transformDynTable(form);
                }else{
                   //非空放入
                    if( dataMap.get(key) != null) {
                        if (Objects.equals(key,"code1") || Objects.equals(key,"code2") ){
                            //key = code1或code2 進行生成條形碼;
                            createBarCode(form,stamper,key,dataMap.get(key));
                        }else if (Objects.equals(key,"qrCode")){
                            //key = qrCode 進行生成二維碼
                            createQrCode(form,stamper,key,dataMap.get(key));
                        }else {
                            form.setField(key, dataMap.get(key).toString());
                        }
                    }

                }
            } catch (Exception e) {
               log.error("pdf賦值異常:{}",e.getMessage());
            }
        }
    }

          /**
          * 動態table的填充
          * @param form
          */
    private void transformDynTable(AcroFields form) {
        if (dynData == null || dynData.size() == 0)
        {return;}
        Object obj = null;
        String name = "";
        String value = "";
        for (int x = 0; x < dynData.size(); x++) {
            obj = dynData.get(x);
            Field[] fld = obj.getClass().getDeclaredFields();
            for (int i = 0; i < fld.length; i++) {
                name = fld[i].getName();
                value = (String) ReflectUtils.getFieldValue(obj, name);
                try {
                    form.setField(name + x, value);
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (DocumentException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
          * 對生成的pdf文件進行后處理
          *
          * @throws RptException
          */
    private synchronized void postProcess() throws Exception {
        FileOutputStream fosRslt = null;
        PdfStamper stamper = null;
        PdfReader reader = null;
        try {
            reader = new PdfReader(cachePath + File.separator + cacheFileName);
            String save = savePath+File.separator+resultFileName;
            File file = new File(save);
            File parentFile = file.getParentFile();
            if (!parentFile.exists()){
                parentFile.mkdirs();
            }
            fosRslt = new FileOutputStream(savePath + File.separator + resultFileName);
            stamper = new PdfStamper(reader, fosRslt);

            Rectangle pageSize = reader.getPageSize(1);
            float width = pageSize.getWidth();
            BaseFont bf = BaseFont.createFont("STSong-Light", "UniGB-UCS2-H",BaseFont.NOT_EMBEDDED);
            PdfContentByte over;
            int total = reader.getNumberOfPages() + 1;
            for (int i = 1; i < total; i++) {
                over = stamper.getOverContent(i);
                if (total <= 2){break;}
                over.beginText();
                over.setFontAndSize(bf, 10);
                over.setTextMatrix(width - 92f, 32);
                over.showText("第 " + i + " 頁");
                over.endText();
            }
        } catch (Exception ie) {
            ie.printStackTrace();
        } finally {
            if (stamper != null) {
                try {
                    stamper.close();
                } catch (DocumentException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fosRslt != null) {
                try { fosRslt.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (reader != null) {
                reader.close();
            }
            File pdfFile = new File(cachePath+File.separator + cacheFileName);
            pdfFile.delete();
        }

    }

    /**
     * PDF中繪制條形碼
     * @param form
     * @param stamper
     * @param key
     * @param value
     */
    public void createBarCode(AcroFields form, PdfStamper stamper,String key,Object value){

        // 獲取屬性的類
        if (value != null && form.getField(key) != null) {
            //獲取位置(左上右下)
            AcroFields.FieldPosition fieldPosition = form.getFieldPositions(key).get(0);
            //繪制條碼
            Barcode128 barcode128 = new Barcode128();
            //字號
            barcode128.setSize(6);
            //條碼高度
            if (key.equals("code1")){
                barcode128.setBarHeight(19.88f);
                barcode128.setBaseline(9);
            }else {
                barcode128.setBarHeight(16.24f);
                //條碼與數字間距
                barcode128.setBaseline(8);
            }
            //條碼值
            barcode128.setCode(value.toString());
            barcode128.setStartStopText(false);
            barcode128.setExtended(true);
            //繪制在第一頁
            PdfContentByte cb = stamper.getOverContent(1);
            //生成條碼圖片
            Image image128 = barcode128.createImageWithBarcode(cb, null, null);
            //條碼位置
            float marginLeft = (fieldPosition.position.getRight() - fieldPosition.position.getLeft() - image128.getWidth()) / 2;
            if (key.equals("code2")){
                //條碼位置
                image128.setAbsolutePosition(fieldPosition.position.getLeft() + marginLeft, 395.67f);
            }else {
                image128.setAbsolutePosition(fieldPosition.position.getLeft() + marginLeft, 157.8f );
            }
            //加入條碼
            try {
                cb.addImage(image128);
            } catch (DocumentException e) {
             log.error("創建條碼異常：{}",e.getMessage());
            }

        }

    }

    /**
     * 繪制二維碼
     * @param form
     * @param stamper
     * @param key
     * @param value
     */
    public void createQrCode(AcroFields form, PdfStamper stamper,String key,Object value){
        // 獲取屬性的類型
        if(value != null && form.getField(key) != null){
            //獲取位置(左上右下)
            AcroFields.FieldPosition fieldPosition = form.getFieldPositions(key).get(0);
            //繪制二維碼
            float width = fieldPosition.position.getRight() - fieldPosition.position.getLeft();
            BarcodeQRCode pdf417 = new BarcodeQRCode(value.toString(), (int)width, (int)width, null);
            //生成二維碼圖像
            Image image128 = null;
            try {
                image128 = pdf417.getImage();
            } catch (BadElementException e) {
                log.error("創建二維碼異常：{}",e.getMessage());
            }
            //繪制在第一頁
            PdfContentByte cb = stamper.getOverContent(1);
            //左邊距(居中處理)
            float marginLeft = (fieldPosition.position.getRight() - fieldPosition.position.getLeft() - image128.getWidth()) / 2;
            //二維碼位置
            image128.setAbsolutePosition(fieldPosition.position.getLeft() + marginLeft, 300);
            image128.setBorderWidth(1000);
            //加入二維碼
            try {
                cb.addImage(image128);
            } catch (DocumentException e) {
                log.error("加入二維碼異常:{}",e.getMessage());
            }
        }
    }

}

import lombok.extern.log4j.Log4j2;
import org.apache.tools.zip.ZipEntry;
import org.apache.tools.zip.ZipOutputStream;

import java.io.*;

/**
 * @description: 文件打ZIP包工具類
 * @author: ZhuCJ  
 * @date: 2020-05-27 14:43
 */
@Log4j2
public class CompressZipUtil {

    /**
     * 壓縮文件（文件夾）
     * @param path   目標文件流
     * @param format zip 格式 | rar 格式
     * @throws Exception
     */
    public static String zipFile(File path, String format) throws Exception {
        String generatePath = "";
        if (path.isDirectory()) {
            generatePath = path.getParent().endsWith(File.separator) == false ?
                    path.getParent() + File.separator + path.getName() + "." + format :
                    path.getParent() + path.getName() + "." + format;
        } else {
            generatePath = path.getParent().endsWith(File.separator) == false ? path.getParent() + File.separator :
                    path.getParent();
            generatePath += path.getName().substring(0, path.getName().lastIndexOf(".")) + "." + format;
        }
        // 輸出流
        FileOutputStream outputStream = new FileOutputStream(generatePath);
        // 壓縮輸出流
        ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(outputStream));
        zip(out, path, "");
        out.flush();
        out.close();

        return generatePath;
    }

    /**
     * @param sourcePath 要壓縮的文件路徑
     * @param suffix     生成的格式后最（zip、rar）
     */
    public static void generateFile(String sourcePath, String suffix) throws Exception {

        File file = new File(sourcePath);
        // 壓縮文件的路徑不存在
        if (!file.exists()) {
            throw new Exception("路徑 " + sourcePath + " 不存在文件，無法進行壓縮...");
        }
        // 用於存放壓縮文件的文件夾
        String generateFile = file.getParent() + File.separator + "CompressFile";
        File compress = new File(generateFile);
        // 如果文件夾不存在，進行創建
        if (!compress.exists()) {
            compress.mkdirs();
        }
        // 目的壓縮文件
        String generateFileName = compress.getAbsolutePath() + File.separator + "AAA" + file.getName() + "." + suffix;

        // 輸入流 表示從一個源讀取數據
        // 輸出流 表示向一個目標寫入數據

        // 輸出流
        FileOutputStream outputStream = new FileOutputStream(generateFileName);

        // 壓縮輸出流
        ZipOutputStream zipOutputStream = new ZipOutputStream(new BufferedOutputStream(outputStream));

        generateFile(zipOutputStream, file, "");

        System.out.println("源文件位置：" + file.getAbsolutePath() + "，目的壓縮文件生成位置：" + generateFileName);
        // 關閉 輸出流
        zipOutputStream.close();
    }

    /**
     * @param out  輸出流
     * @param file 目標文件
     * @param dir  文件夾
     * @throws Exception
     */
    private static void generateFile(ZipOutputStream out, File file, String dir) {
        FileInputStream inputStream = null;
        try {
            // 當前的是文件夾，則進行一步處理
            if (file.isDirectory()) {
                //得到文件列表信息
                File[] files = file.listFiles();

                //將文件夾添加到下一級打包目錄
                out.putNextEntry(new ZipEntry(dir + File.separator));

                dir = dir.length() == 0 ? "" : dir + File.separator;

                //循環將文件夾中的文件打包
                for (int i = 0; i < files.length; i++) {
                    generateFile(out, files[i], dir + files[i].getName());
                }

            } else { // 當前是文件

                // 輸入流
                inputStream = new FileInputStream(file);
                // 標記要打包的條目
                out.putNextEntry(new ZipEntry(dir));
                // 進行寫操作
                int len = 0;
                byte[] bytes = new byte[1024];
                while ((len = inputStream.read(bytes)) > 0) {
                    out.write(bytes, 0, len);
                }

            }
        } catch (Exception e) {
            log.error("generateFile異常:", e);
        } finally {
            // 關閉輸入流
            try {
                if (inputStream != null) {
                    inputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }

    /**
     * 遞歸壓縮文件
     *
     * @param output    ZipOutputStream 對象流
     * @param file      壓縮的目標文件流
     * @param childPath 條目目錄
     */
    private static void zip(ZipOutputStream output, File file, String childPath) {
        FileInputStream input = null;
        try {
            // 文件為目錄
            if (file.isDirectory()) {
                // 得到當前目錄里面的文件列表
                File list[] = file.listFiles();
                childPath = childPath + (childPath.length() == 0 ? "" : File.separator)
                        + file.getName();
                // 循環遞歸壓縮每個文件
                for (File f : list) {
                    zip(output, f, childPath);
                }
            } else {
                // 壓縮文件
                childPath = (childPath.length() == 0 ? "" : childPath + File.separator)
                        + file.getName();
                output.putNextEntry(new ZipEntry(childPath));
                input = new FileInputStream(file);
                int readLen = 0;
                byte[] buffer = new byte[1024 * 8];
                while ((readLen = input.read(buffer, 0, 1024 * 8)) != -1) {
                    output.write(buffer, 0, readLen);
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            // 關閉流
            if (input != null) {
                try {
                    input.close();
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        }

    }

}

import lombok.extern.slf4j.Slf4j;

import java.io.File;

/**
 * @description: 刪除指定文件或文件夾下所有內容
 * @author: ZhuCJ 
 * @date: 2020-06-02 0:18
 */
@Slf4j
public class DeleteFileUtil {

    public static void deleteFile(File file){
        //取得這個目錄下的所有子文件對象
        File[] files = file.listFiles();
        //遍歷該目錄下的文件對象
        for (File f: files){
            //判斷子目錄是否存在子目錄,如果是文件則刪除
            if (f.isDirectory()){
                deleteFile(f);
            }else {
                f.delete();
            }
        }
        //刪除空文件夾  for循環已經把上一層節點的目錄清空。
        file.delete();
    }
}

import org.apache.commons.lang3.Validate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.StringUtils;

import java.lang.reflect.*;
import java.util.Date;

/**
 * @description: 反射設置對象屬性值
 * @author: ZhuCJ
 * @date: 2020-05-27 11:16
 */
public class ReflectUtils {

    private static final String SETTER_PREFIX = "set";

    private static final String GETTER_PREFIX = "get";

    private static final String CGLIB_CLASS_SEPARATOR = "$$";

    private static Logger logger = LoggerFactory.getLogger(ReflectUtils.class);

    /**
     * 調用Getter方法.
     * 支持多級，如：對象名.對象名.方法
     */
    public static Object invokeGetter(Object obj, String propertyName) {
        Object object = obj;
        for (String name : StringUtils.split(propertyName, ".")){
            String getterMethodName = GETTER_PREFIX + org.springframework.util.StringUtils.capitalize(name);
            object = invokeMethod(object, getterMethodName, new Class[] {}, new Object[] {});
        }
        return object;
    }

    /**
     * 調用Setter方法, 僅匹配方法名。
     * 支持多級，如：對象名.對象名.方法
     */
    public static void invokeSetter(Object obj, String propertyName, Object value) {
        Object object = obj;
        String[] names = StringUtils.split(propertyName, ".");
        for (int i=0; i<names.length; i++){
            if(i<names.length-1){
                String getterMethodName = GETTER_PREFIX + StringUtils.capitalize(names[i]);
                object = invokeMethod(object, getterMethodName, new Class[] {}, new Object[] {});
            }else{
                String setterMethodName = SETTER_PREFIX + StringUtils.capitalize(names[i]);
                invokeMethodByName(object, setterMethodName, new Object[] { value });
            }
        }
    }

    /**
     * 直接讀取對象屬性值, 無視private/protected修飾符, 不經過getter函數.
     */
    public static Object getFieldValue(final Object obj, final String fieldName) {
        Field field = getAccessibleField(obj, fieldName);

        if (field == null) {
            throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + obj + "]");
        }

        Object result = null;
        try {
            result = field.get(obj);
        } catch (IllegalAccessException e) {
            logger.error("不可能拋出的異常{}", e.getMessage());
        }
        return result;
    }

    /**
     * 直接設置對象屬性值, 無視private/protected修飾符, 不經過setter函數.
     */
    public static void setFieldValue(final Object obj, final String fieldName, final Object value) {
        Field field = getAccessibleField(obj, fieldName);

        if (field == null) {
            throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + obj + "]");
        }

        try {
            field.set(obj, value);
        } catch (IllegalAccessException e) {
            logger.error("不可能拋出的異常:{}", e.getMessage());
        }
    }

    /**
     * 直接調用對象方法, 無視private/protected修飾符.
     * 用於一次性調用的情況，否則應使用getAccessibleMethod()函數獲得Method后反復調用.
     * 同時匹配方法名+參數類型，
     */
    public static Object invokeMethod(final Object obj, final String methodName, final Class<?>[] parameterTypes,
                                      final Object[] args) {
        Method method = getAccessibleMethod(obj, methodName, parameterTypes);
        if (method == null) {
            throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + obj + "]");
        }

        try {
            return method.invoke(obj, args);
        } catch (Exception e) {
            throw convertReflectionExceptionToUnchecked(e);
        }
    }

    /**
     * 直接調用對象方法, 無視private/protected修飾符，
     * 用於一次性調用的情況，否則應使用getAccessibleMethodByName()函數獲得Method后反復調用.
     * 只匹配函數名，如果有多個同名函數調用第一個。
     */
    public static Object invokeMethodByName(final Object obj, final String methodName, final Object[] args) {
        Method method = getAccessibleMethodByName(obj, methodName);
        if (method == null) {
            throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + obj + "]");
        }

        try {
            return method.invoke(obj, args);
        } catch (Exception e) {
            throw convertReflectionExceptionToUnchecked(e);
        }
    }

    /**
     * 循環向上轉型, 獲取對象的DeclaredField, 並強制設置為可訪問.
     *
     * 如向上轉型到Object仍無法找到, 返回null.
     */
    public static Field getAccessibleField(final Object obj, final String fieldName) {
        Validate.notNull(obj, "object can't be null");
        Validate.notBlank(fieldName, "fieldName can't be blank");
        for (Class<?> superClass = obj.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()) {
            try {
                Field field = superClass.getDeclaredField(fieldName);
                makeAccessible(field);
                return field;
            } catch (NoSuchFieldException e) {//NOSONAR
                // Field不在當前類定義,繼續向上轉型
                continue;// new add
            }
        }
        return null;
    }

    /**
     * 循環向上轉型, 獲取對象的DeclaredMethod,並強制設置為可訪問.
     * 如向上轉型到Object仍無法找到, 返回null.
     * 匹配函數名+參數類型。
     *
     * 用於方法需要被多次調用的情況. 先使用本函數先取得Method,然后調用Method.invoke(Object obj, Object... args)
     */
    public static Method getAccessibleMethod(final Object obj, final String methodName,
                                             final Class<?>... parameterTypes) {
        Validate.notNull(obj, "object can't be null");
        Validate.notBlank(methodName, "methodName can't be blank");

        for (Class<?> searchType = obj.getClass(); searchType != Object.class; searchType = searchType.getSuperclass()) {
            try {
                Method method = searchType.getDeclaredMethod(methodName, parameterTypes);
                makeAccessible(method);
                return method;
            } catch (NoSuchMethodException e) {
                // Method不在當前類定義,繼續向上轉型
                continue;// new add
            }
        }
        return null;
    }

    /**
     * 循環向上轉型, 獲取對象的DeclaredMethod,並強制設置為可訪問.
     * 如向上轉型到Object仍無法找到, 返回null.
     * 只匹配函數名。
     *
     * 用於方法需要被多次調用的情況. 先使用本函數先取得Method,然后調用Method.invoke(Object obj, Object... args)
     */
    public static Method getAccessibleMethodByName(final Object obj, final String methodName) {
        Validate.notNull(obj, "object can't be null");
        Validate.notBlank(methodName, "methodName can't be blank");

        for (Class<?> searchType = obj.getClass(); searchType != Object.class; searchType = searchType.getSuperclass()) {
            Method[] methods = searchType.getDeclaredMethods();
            for (Method method : methods) {
                if (method.getName().equals(methodName)) {
                    makeAccessible(method);
                    return method;
                }
            }
        }
        return null;
    }

    /**
     * 改變private/protected的方法為public，盡量不調用實際改動的語句，避免JDK的SecurityManager抱怨。
     */
    public static void makeAccessible(Method method) {
        if ((!Modifier.isPublic(method.getModifiers()) || !Modifier.isPublic(method.getDeclaringClass().getModifiers()))
                && !method.isAccessible()) {
            method.setAccessible(true);
        }
    }

    /**
     * 改變private/protected的成員變量為public，盡量不調用實際改動的語句，避免JDK的SecurityManager抱怨。
     */
    public static void makeAccessible(Field field) {
        if ((!Modifier.isPublic(field.getModifiers()) || !Modifier.isPublic(field.getDeclaringClass().getModifiers()) || Modifier
                .isFinal(field.getModifiers())) && !field.isAccessible()) {
            field.setAccessible(true);
        }
    }

    /**
     * 通過反射, 獲得Class定義中聲明的泛型參數的類型, 注意泛型必須定義在父類處
     * 如無法找到, 返回Object.class.
     * eg.
     * public UserDao extends HibernateDao<User>
     *
     * @param clazz The class to introspect
     * @return the first generic declaration, or Object.class if cannot be determined
     */
    @SuppressWarnings("unchecked")
    public static <T> Class<T> getClassGenricType(final Class clazz) {
        return getClassGenricType(clazz, 0);
    }

    /**
     * 通過反射, 獲得Class定義中聲明的父類的泛型參數的類型.
     * 如無法找到, 返回Object.class.
     *
     * 如public UserDao extends HibernateDao<User,Long>
     *
     * @param clazz clazz The class to introspect
     * @param index the Index of the generic ddeclaration,start from 0.
     * @return the index generic declaration, or Object.class if cannot be determined
     */
    public static Class getClassGenricType(final Class clazz, final int index) {

        Type genType = clazz.getGenericSuperclass();

        if (!(genType instanceof ParameterizedType)) {
            logger.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType");
            return Object.class;
        }

        Type[] params = ((ParameterizedType) genType).getActualTypeArguments();

        if (index >= params.length || index < 0) {
            logger.warn("Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: "
                    + params.length);
            return Object.class;
        }
        if (!(params[index] instanceof Class)) {
            logger.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
            return Object.class;
        }

        return (Class) params[index];
    }

    public static Class<?> getUserClass(Object instance) {
        Validate.notNull(instance, "Instance must not be null");
        Class clazz = instance.getClass();
        if (clazz != null && clazz.getName().contains(CGLIB_CLASS_SEPARATOR)) {
            Class<?> superClass = clazz.getSuperclass();
            if (superClass != null && !Object.class.equals(superClass)) {
                return superClass;
            }
        }
        return clazz;

    }

    /**
     * 將反射時的checked exception轉換為unchecked exception.
     */
    public static RuntimeException convertReflectionExceptionToUnchecked(Exception e) {
        if (e instanceof IllegalAccessException || e instanceof IllegalArgumentException
                || e instanceof NoSuchMethodException) {
            return new IllegalArgumentException(e);
        } else if (e instanceof InvocationTargetException) {
            return new RuntimeException(((InvocationTargetException) e).getTargetException());
        } else if (e instanceof RuntimeException) {
            return (RuntimeException) e;
        }
        return new RuntimeException("Unexpected Checked Exception.", e);
    }

    /**
     * 判斷屬性是否為日期類型
     *
     * @param clazz
     *            數據類型
     * @param fieldName
     *            屬性名
     * @return 如果為日期類型返回true，否則返回false
     */
    public static <T> boolean isDateType(Class<T> clazz, String fieldName) {
        boolean flag = false;
        try {
            Field field = clazz.getDeclaredField(fieldName);
            Object typeObj = field.getType().newInstance();
            flag = typeObj instanceof Date;
        } catch (Exception e) {
            // 把異常吞掉直接返回false
        }
        return flag;
    }

    /**
     * 根據類型將指定參數轉換成對應的類型
     *
     * @param value
     *            指定參數
     * @param type
     *            指定類型
     * @return 返回類型轉換后的對象
     */
    public static <T> Object parseValueWithType(String value, Class<?> type) {
        Object result = null;
        try { // 根據屬性的類型將內容轉換成對應的類型
            if (Boolean.TYPE == type) {
                result = Boolean.parseBoolean(value);
            } else if (Byte.TYPE == type) {
                result = Byte.parseByte(value);
            } else if (Short.TYPE == type) {
                result = Short.parseShort(value);
            } else if (Integer.TYPE == type) {
                result = Integer.parseInt(value);
            } else if (Long.TYPE == type) {
                result = Long.parseLong(value);
            } else if (Float.TYPE == type) {
                result = Float.parseFloat(value);
            } else if (Double.TYPE == type) {
                result = Double.parseDouble(value);
            } else {
                result = (Object) value;
            }
        } catch (Exception e) {
            // 把異常吞掉直接返回null
        }
        return result;
    }
}

4.使用的maven依賴

<!--文件轉成PDF-->
<dependency>
    <groupId>com.itextpdf</groupId>
    <artifactId>itextpdf</artifactId>
    <version>5.5.13</version>
</dependency>
<!--打成zip壓縮包-->
<dependency>
    <groupId>org.apache.ant</groupId>
    <artifactId>ant</artifactId>
    <version>1.10.5</version>
</dependency>