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>