java二维码生成导出成压缩包

效果：

首先引入zxing依赖：

<lombok.version>1.18.8</lombok.version>
<zxing.version>3.3.3</zxing.version>

<!--lombok插件-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>${lombok.version}</version>
    <scope>provided</scope>
</dependency>


<!-- 条形码、二维码生成 -->
<dependency>
    <groupId>com.google.zxing</groupId>
    <artifactId>core</artifactId>
    <version>${zxing.version}</version>
</dependency>
<dependency>
    <groupId>com.google.zxing</groupId>
    <artifactId>javase</artifactId>
    <version>${zxing.version}</version>
</dependency>

 

操作图片的工具类：

import com.google.zxing.LuminanceSource;

import java.awt.*;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;

/**
 *  
 *  * @projectName xx
 *  * @title     BufferedImageLuminanceSource   
 *  * @package    com.xx.common.utils  
 *  * @description    图片工具  
 *  * @author IT_CREAT     
 *  * @date  2019 2019/11/5 14:22  
 *  * @version V1.0.0 
 *  
 */
public class BufferedImageLuminanceSource extends LuminanceSource {

    private final BufferedImage image;
    private final int left;
    private final int top;

    public BufferedImageLuminanceSource(BufferedImage image) {
        this(image, 0, 0, image.getWidth(), image.getHeight());
    }

    /**
     * 构造方法
     * @param image
     * @param left
     * @param top
     * @param width
     * @param height
     */
    public BufferedImageLuminanceSource(BufferedImage image, int left, int top, int width, int height) {
        super(width, height);

        int sourceWidth = image.getWidth();
        int sourceHeight = image.getHeight();
        if (left + width > sourceWidth || top + height > sourceHeight) {
            throw new IllegalArgumentException("Crop rectangle does not fit within image data.");
        }

        for (int y = top; y < top + height; y++) {
            for (int x = left; x < left + width; x++) {
                if ((image.getRGB(x, y) & 0xFF000000) == 0) {
                    image.setRGB(x, y, 0xFFFFFFFF); // = white
                }
            }
        }
        this.image = new BufferedImage(sourceWidth, sourceHeight, BufferedImage.TYPE_BYTE_GRAY);
        this.image.getGraphics().drawImage(image, 0, 0, null);
        this.left = left;
        this.top = top;
    }

    @Override
    public byte[] getRow(int y, byte[] row) {//从底层平台的位图提取一行（only one row）的亮度数据值
        if (y < 0 || y >= getHeight()) {
            throw new IllegalArgumentException("Requested row is outside the image: " + y);
        }
        int width = getWidth();
        if (row == null || row.length < width) {
            row = new byte[width];
        }
        image.getRaster().getDataElements(left, top + y, width, 1, row);
        return row;
    }

    @Override
    public byte[] getMatrix() {///从底层平台的位图提取亮度数据值
        int width = getWidth();
        int height = getHeight();
        int area = width * height;
        byte[] matrix = new byte[area];
        image.getRaster().getDataElements(left, top, width, height, matrix);
        return matrix;
    }

    @Override
    public boolean isCropSupported() {//是否支持裁剪
        return true;
    }

    /**
     * 返回一个新的对象与裁剪的图像数据。实现可以保存对原始数据的引用，而不是复制。
     */
    @Override
    public LuminanceSource crop(int left, int top, int width, int height) {
        return new BufferedImageLuminanceSource(image, this.left + left, this.top + top, width, height);
    }

    @Override
    public boolean isRotateSupported() {//是否支持旋转
        return true;
    }

    @Override
    public LuminanceSource rotateCounterClockwise() {//逆时针旋转图像数据的90度，返回一个新的对象。
        int sourceWidth = image.getWidth();
        int sourceHeight = image.getHeight();
        AffineTransform transform = new AffineTransform(0.0, -1.0, 1.0, 0.0, 0.0, sourceWidth);
        BufferedImage rotatedImage = new BufferedImage(sourceHeight, sourceWidth, BufferedImage.TYPE_BYTE_GRAY);
        Graphics2D g = rotatedImage.createGraphics();
        g.drawImage(image, transform, null);
        g.dispose();
        int width = getWidth();
        return new BufferedImageLuminanceSource(rotatedImage, top, sourceWidth - (left + width), getHeight(), width);
    }

}

zip压缩工具类：

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import org.springframework.util.CollectionUtils;

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

/**
 *  
 *  * @projectName xx
 *  * @title     ZipUtil   
 *  * @package    com.xx.common.utils  
 *  * @description    压缩文件
 *  * @author IT_CREAT     
 *  * @date  2019 2019/9/30 1:41  
 *  * @version V1.0.0 
 *  
 */
public class ZipUtil {

    /**
     * 将一系列文件压缩进zip文件
     * @param fileName zip文件的名称，不带后缀
     * @param waitZipFileRealPaths  需要压缩的文件路径集合
     * @return 生成的压缩文件路径
     * @throws Exception 异常
     */
    public static String createZipFile(String fileName, List<String> waitZipFileRealPaths) throws Exception {
        String filePath = LocalFilePathUtil.createFilePath(fileName, ".zip");
        List<File> srcFiles = new ArrayList<>();
        for (String filePathName:waitZipFileRealPaths){
            File file = new File(filePathName);
            if(file.exists()){
                srcFiles.add(file);
            }
        }
        zipFiles((File[]) srcFiles.toArray(),null,new File(filePath));
        return filePath;
    }

    /**
     * 将一系列文件压缩进zip文件
     * @param fileName zip文件的名称，当deFilePath文件路径为空不带后缀,deFilePath文件路径不为空必须带后缀
     * @param waitZipFilesOutput  需要压缩的文件的封装输出流实体类
     * @param deFilePath  指定文件压缩后的文件路径，可不指定，不指定调用系统application默认上传路径，这里是便于测试
     * @return 生成的压缩文件路径
     * @throws Exception 异常
     */
    public static String createZipFile2(String fileName, List<FileOutDto> waitZipFilesOutput,String deFilePath) throws Exception {
        String filePath = null;
        if(!StringUtils.isEmpty(deFilePath)){
            File file = new File(deFilePath);
            if(!file.exists()){
                file.mkdirs();
            }
            filePath = deFilePath + fileName;
        }else {
            filePath = LocalFilePathUtil.createFilePath(fileName, ".zip");
        }
        zipFiles(null,waitZipFilesOutput,new File(filePath));
        return filePath;
    }

    public static void zipFiles(File[] srcFiles, List<FileOutDto> fileOutDtos,File zipFile) throws Exception {
        // 判断压缩后的文件存在不，不存在则创建
        if (!zipFile.exists()) {
            zipFile.createNewFile();
        }
        // 创建 FileOutputStream 对象
        FileOutputStream fileOutputStream = null;
        // 创建 ZipOutputStream
        ZipOutputStream zipOutputStream = null;
        // 创建 FileInputStream 对象
        FileInputStream fileInputStream = null;

        // 实例化 FileOutputStream 对象
        fileOutputStream = new FileOutputStream(zipFile);
        // 实例化 ZipOutputStream 对象
        zipOutputStream = new ZipOutputStream(fileOutputStream);
        // 创建 ZipEntry 对象
        ZipEntry zipEntry = null;
        // 遍历源文件数组
        if(null != srcFiles){
            for (int i = 0; i < srcFiles.length; i++) {
                // 将源文件数组中的当前文件读入 FileInputStream 流中
                fileInputStream = new FileInputStream(srcFiles[i]);
                // 实例化 ZipEntry 对象，源文件数组中的当前文件
                zipEntry = new ZipEntry(srcFiles[i].getName());
                zipOutputStream.putNextEntry(zipEntry);
                // 该变量记录每次真正读的字节个数
                int len;
                // 定义每次读取的字节数组
                byte[] buffer = new byte[1024];
                while ((len = fileInputStream.read(buffer)) > 0) {
                    zipOutputStream.write(buffer, 0, len);
                }
            }
        }else {
            if(!CollectionUtils.isEmpty(fileOutDtos)){
              for(FileOutDto fileOutDto : fileOutDtos) {
                  // 实例化 ZipEntry 对象，源文件数组中的当前文件
                  zipEntry = new ZipEntry(fileOutDto.getFileName());
                  zipOutputStream.putNextEntry(zipEntry);

                  ByteArrayOutputStream byteArrayOutputStream = fileOutDto.getByteArrayOutputStream();
                  byte[] bytes = byteArrayOutputStream.toByteArray();
                  zipOutputStream.write(bytes,0,bytes.length);
              }
            }
        }
        zipOutputStream.closeEntry();
        zipOutputStream.close();
        if(null != fileInputStream){
            fileInputStream.close();
        }
        fileOutputStream.close();
    }

    /**
     * s
     * 压缩单个文件或者文件夹及其子文件夹进zip
     *
     * @param srcFilePath  压缩源路径
     * @param destFilePath 压缩目的路径
     */
    public static void compress(String srcFilePath, String destFilePath) {
        File src = new File(srcFilePath);
        if (!src.exists()) {
            throw new RuntimeException(srcFilePath + "不存在");
        }
        File zipFile = new File(destFilePath);
        try {
            FileOutputStream fos = new FileOutputStream(zipFile);
            ZipOutputStream zos = new ZipOutputStream(fos);
            String baseDir = "";
            compressbyType(src, zos, baseDir);
            zos.close();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /**
     * 按照原路径的类型就行压缩。文件路径直接把文件压缩，
     *
     * @param src
     * @param zos
     * @param baseDir
     */
    private static void compressbyType(File src, ZipOutputStream zos, String baseDir) {
        if (!src.exists())
            return;
        System.out.println("压缩路径" + baseDir + src.getName());
        //判断文件是否是文件，如果是文件调用compressFile方法,如果是路径，则调用compressDir方法；
        if (src.isFile()) {
            //src是文件，调用此方法
            compressFile(src, zos, baseDir);
        } else if (src.isDirectory()) {
            //src是文件夹，调用此方法
            compressDir(src, zos, baseDir);
        }
    }

    /**
     * 压缩文件
     */
    private static void compressFile(File file, ZipOutputStream zos, String baseDir) {
        if (!file.exists())
            return;
        try {
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
            ZipEntry entry = new ZipEntry(baseDir + file.getName());
            zos.putNextEntry(entry);
            int count;
            byte[] buf = new byte[1024];
            while ((count = bis.read(buf)) != -1) {
                zos.write(buf, 0, count);
            }
            bis.close();

        } catch (Exception e) {
            // TODO: handle exception

        }
    }

    /**
     * 压缩文件夹
     */
    private static void compressDir(File dir, ZipOutputStream zos, String baseDir) {
        if (!dir.exists())
            return;
        File[] files = dir.listFiles();
        if (files.length == 0) {
            try {
                zos.putNextEntry(new ZipEntry(baseDir + dir.getName() + File.separator));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        for (File file : files) {
            compressbyType(file, zos, baseDir + dir.getName() + File.separator);
        }
    }

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @Accessors(chain = true)
    public static class FileOutDto{
        private String fileName;
        private ByteArrayOutputStream byteArrayOutputStream;
    }

    public static void main(String[] args) throws Exception {
        compress("D:/file/测试.png", "D:/file/测试.zip");
        compress("D:/file/测试.pdf", "D:/file/测试.zip");

//        File[] srcFiles = { new File("D:/file/测试.png"), new File("D:/file/测试.pdf")};
//        File zipFile = new File("D:/file/测试2.zip");
//        // 调用压缩方法
//        zipFiles(srcFiles, zipFile);
        String[] srcFilePath = {"D:/file/测试.png","D:/file/测试.pdf"};

        String path = createZipFile("测试2", Arrays.asList(srcFilePath));
    }


}

二维码生成工具类：

import com.google.zxing.*;
import com.google.zxing.common.BitMatrix;
import com.google.zxing.common.HybridBinarizer;
import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;
import com.xx.common.core.domain.AjaxResult;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.geom.RoundRectangle2D;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.Random;

/**
 *  
 *  * @projectName xx
 *  * @title     QRCodeUtil   
 *  * @package    com.xx.common.utils  
 *  * @description    二维码生成工具
 *  * @author IT_CREAT     
 *  * @date  2019 2019/11/5 14:25  
 *  * @version V1.0.0 
 *  
 */
@Slf4j
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class QRCodeUtil {

    /**编码utf-8*/
    private static final String CHARSET = "utf-8";
    /**二维码图片格式JPG*/
    private static final String FORMAT_NAME = "JPG";

    /**二维码尺寸*/
    private int QRCODE_SIZE = 300;
    /**LOGO宽度*/
    private int WIDTH = 100;
    /**LOGO高度*/
    private int HEIGHT = 100;

    private Image srcImg = null;


    public static QRCodeUtil create(){
        return new QRCodeUtil();
    }

    /**
     * 生成二维码
     * @param content	源内容
     * @param imgPath	生成二维码保存的路径
     * @param needCompress	是否要压缩logo图片，当logo大于设置高宽进行压缩
     * @param useSetWidthAndHeight	在设置logo为压缩的情况下，是否直接启用设置的高宽
     * @return		返回二维码图片
     * @throws Exception
     */
    private BufferedImage createImage(String content, String imgPath, InputStream logoImgInput,boolean needCompress,boolean useSetWidthAndHeight) throws Exception {
        Hashtable hints = new Hashtable();
        hints.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.H);
        hints.put(EncodeHintType.CHARACTER_SET, CHARSET);
        hints.put(EncodeHintType.MARGIN, 1);
        BitMatrix bitMatrix = new MultiFormatWriter().encode(content, BarcodeFormat.QR_CODE, QRCODE_SIZE, QRCODE_SIZE,
                hints);
        int width = bitMatrix.getWidth();
        int height = bitMatrix.getHeight();
        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        for (int x = 0; x < width; x++) {
            for (int y = 0; y < height; y++) {
                image.setRGB(x, y, bitMatrix.get(x, y) ? 0xFF000000 : 0xFFFFFFFF);
            }
        }
        if ((imgPath == null || "".equals(imgPath)) && ObjectUtils.isEmpty(logoImgInput)) {
            return image;
        }
        // 插入图片
        insertImage(image, imgPath,logoImgInput,needCompress,useSetWidthAndHeight);
        return image;
    }

    /**
     * 在生成的二维码中插入图片
     * @param source
     * @param imgPath
     * @param needCompress
     * @throws Exception
     */
    private void insertImage(BufferedImage source, String imgPath,InputStream logoImgInput, boolean needCompress,boolean useSetWidthAndHeight) throws Exception {
        Image src = null;
        if(ObjectUtils.isEmpty(logoImgInput)){
            File file1 = new File(imgPath);
            if (!file1.exists()) {
                System.err.println("" + imgPath + "   该文件不存在！");
                return;
            }
            src = ImageIO.read(new File(imgPath));
        }else {
            src = ImageIO.read(logoImgInput);
        }
        if(ObjectUtils.isEmpty(srcImg)){
            srcImg = src;
        }else {
            src = srcImg;
        }
        int width = src.getWidth(null);
        int height = src.getHeight(null);
        if (needCompress) { // 压缩LOGO
            if(useSetWidthAndHeight){
                width = this.WIDTH;
                height = this.HEIGHT;
            }else {
                if (width > this.WIDTH) {
                    width = this.WIDTH;
                }
                if (height > this.HEIGHT) {
                    height = this.HEIGHT;
                }
            }
            Image image = src.getScaledInstance(width, height, Image.SCALE_SMOOTH);
            BufferedImage tag = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
            Graphics g = tag.getGraphics();
            g.drawImage(image, 0, 0, null); // 绘制缩小后的图
            g.dispose();
            src = image;
        }
        // 插入LOGO
        Graphics2D graph = source.createGraphics();
        int x = (QRCODE_SIZE - width) / 2;
        int y = (QRCODE_SIZE - height) / 2;
        graph.drawImage(src, x, y, width, height, null);
        Shape shape = new RoundRectangle2D.Float(x, y, width, width, 6, 6);
        graph.setStroke(new BasicStroke(3f));
        graph.draw(shape);
        graph.dispose();
    }

    /**
     * 生成带logo二维码，并保存到磁盘
     * @param content 二维码内容
     * @param imgPath	logo图片
     * @param destPath  二维码输出路径
     * @param needCompress 是否需要压缩logo图片
     * @param fileName 二维码文件名称带后缀
     * @throws Exception 异常
     */
    public void encode(String content, String imgPath,InputStream logoImgInput, String destPath, boolean needCompress,String fileName) throws Exception {
        BufferedImage image = createImage(content, imgPath,logoImgInput, needCompress,false);
        mkdirs(destPath);

        ImageIO.write(image, FORMAT_NAME, new File(destPath + "/" + fileName));
    }

    /**
     * 生成带logo二维码，返回输出流
     * @param content 二维码内容
     * @param imgPath logo图片路径
     * @param needCompress 是否需要压缩
     * @return 二维码输出流
     * @throws Exception
     */
    public ByteArrayOutputStream encode2(String content, String imgPath, InputStream logoImgInput,boolean needCompress,boolean useSetWidthAndHeight) throws Exception {
        BufferedImage image = createImage(content, imgPath,logoImgInput, needCompress,useSetWidthAndHeight);
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        boolean write = ImageIO.write(image, FORMAT_NAME, outputStream);
        if(write == true){
            return outputStream;
        }
        return null;
    }

    /**
     * 生成二维码并打包压缩
     * @param doubleCode  需要生成的二维码内容集合
     * @param logoImgPath logo图片地址
     * @param logoImgInput logo图片输入流,可传入地址或输入流二选一，优先输入流
     * @param needCompress 是否需要图片压缩
     * @param useSetWidthAndHeight 在设置logo为压缩的情况下，是否直接启用设置的高宽
     * @param zipName zip压缩包的名字
     * @param zipPath 指定文件压缩后的文件路径，可不指定，不指定调用系统application默认上传路径，这里是便于测试
     * @return 状态信息
     */
    public AjaxResult createCode2Zip(List<DoubleCode> doubleCode, String logoImgPath, InputStream logoImgInput, boolean needCompress,boolean useSetWidthAndHeight, String zipName, String zipPath){
        if(CollectionUtils.isEmpty(doubleCode)){
            return AjaxResult.error("需要生成的二维码内容为空，无法生成");
        }
        try {
            List<ZipUtil.FileOutDto> fileOutDtos = new ArrayList<>();
            for(DoubleCode code:doubleCode){
                ByteArrayOutputStream outputStream = encode2(code.getCreateImgContent(), logoImgPath, logoImgInput,needCompress,useSetWidthAndHeight);
                if(null != outputStream){
                    ZipUtil.FileOutDto fileOutDto = new ZipUtil.FileOutDto();
                    fileOutDto.setFileName(code.getCreateImgName())
                            .setByteArrayOutputStream(outputStream);
                    fileOutDtos.add(fileOutDto);
                }
            }
            String zipFile2 = ZipUtil.createZipFile2(zipName, fileOutDtos,zipPath);
            return AjaxResult.success(zipFile2);
        }catch (Exception e){
            e.printStackTrace();
            log.info(e.getMessage());
            return AjaxResult.error("生成二维码出现异常，请联系管理员或稍后重试");
        }
    }

    public void mkdirs(String destPath) {
        File file = new File(destPath);
        // 当文件夹不存在时，mkdirs会自动创建多层目录，区别于mkdir。(mkdir如果父目录不存在则会抛出异常)
        if (!file.exists() && !file.isDirectory()) {
            file.mkdirs();
        }
    }

    public void encode(String content, String imgPath, String destPath,String file) throws Exception {
        encode(content, imgPath, null,destPath, false ,file);
    }

    public void encode(String content, String destPath, boolean needCompress,String file) throws Exception {
        encode(content, null, null,destPath, needCompress,file);
    }

    public void encode(String content, String destPath,String file) throws Exception {
        encode(content, null, null,destPath, false,file);
    }

    public void encode(String content, String imgPath, OutputStream output, boolean needCompress)
            throws Exception {
        BufferedImage image = createImage(content, imgPath,null, needCompress,false);
        ImageIO.write(image, FORMAT_NAME, output);
    }

    public void encode(String content, OutputStream output) throws Exception {
        encode(content, null, output, false);
    }

    /**
     * 从二维码中，解析数据
     * @param file	二维码图片文件
     * @return	 返回从二维码中解析到的数据值
     * @throws Exception
     */
    public String decode(File file) throws Exception {
        BufferedImage image;
        image = ImageIO.read(file);
        if (image == null) {
            return null;
        }
        BufferedImageLuminanceSource source = new BufferedImageLuminanceSource(image);
        BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(source));
        Result result;
        Hashtable hints = new Hashtable();
        hints.put(DecodeHintType.CHARACTER_SET, CHARSET);
        result = new MultiFormatReader().decode(bitmap, hints);
        String resultStr = result.getText();
        return resultStr;
    }

    public String decode(String path) throws Exception {
        return decode(new File(path));
    }

    /**二维码需要生成内容的实体类*/
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @Accessors(chain = true)
    public static class DoubleCode{
        /**生成二维码图片的名字带后缀，必须为jpg*/
        private String createImgName;
        /**生成二维码的内容*/
        private String createImgContent;
    }


    /**测试*/
    public static void main(String[] args) throws Exception {
        String textt = "xxxxxx二维码";//二维码的内容
        String logo = "d:"+"/logo.png";//logo的路径
        String file = new Random().nextInt(99999999) + ".jpg";//生成随机文件名
        System.out.println("生成二维码文件名"+file.toString());
        String path = "D:/";

        QRCodeUtil.create().encode(textt,logo,null,path,true,file);//path 二维码保存的服务器的路径


        List<DoubleCode> doubleCodes = new ArrayList<>();
        DoubleCode code = new DoubleCode();
        code.setCreateImgName("苹果笔记本-0006878954725.jpg")
                .setCreateImgContent("0006878954725");
        doubleCodes.add(code);
        code = new DoubleCode();
        code.setCreateImgName("华为笔记本-0006866754725.jpg")
                .setCreateImgContent("0006866754725");
        doubleCodes.add(code);
        AjaxResult result = QRCodeUtil.create().createCode2Zip(doubleCodes, logo,null, true, false,"二维码压缩包.zip", "D:/");
        System.out.println(result);
    }




}

 

获取本地文件路径工具类：

import com.xx.common.config.Global;

import java.io.File;
import java.util.UUID;

/**
 *  
 *  * @projectName ruoyi
 *  * @title     LocalFilePathUtil   
 *  * @package    com.ruoyi.common.utils  
 *  * @description    快速创建文件全路径工具类
 *  * @author IT_CREAT     
 *  * @date  2019 2019/9/30 2:03  
 *  * @version V1.0.0 
 *  
 */
public class LocalFilePathUtil {

    /**
     * 快速创建本地文件全路径路径名
     * @param filename 文件名字 如：" 测试文件 "
     * @param suffix 文件后缀 ：如：" .pdf "
     * @return 全路径名
     */
    public static String createFilePath(String filename, String suffix){
        String fileName = encodingFilename(filename, suffix);
        return getAbsoluteFile(fileName);
    }

    /**
     * 编码文件名
     *
     * @param filename 文件名称
     * @param suffix   文件后缀
     * @return 编码后的文件名
     */
    public static String encodingFilename(String filename, String suffix) {
        filename = UUID.randomUUID().toString() + "_" + filename + suffix;
        return filename;
    }

    /**
     * 获取下载路径
     *
     * @param filename 文件名称
     */
    public static String getAbsoluteFile(String filename) {
        String downloadPath = Global.getDownloadPath() + filename;
        File desc = new File(downloadPath);
        if (!desc.getParentFile().exists()) {
            desc.getParentFile().mkdirs();
        }
        return downloadPath;
    }



}

 

 

 

 

全局配置类：

application.yml

# 项目相关配置
vcsrm:
  # 名称
  name: vcsrm_dxl
  # 版本
  version: 4.0.0
  # 版权年份
  copyrightYear: 2019
  # 实例演示开关
  demoEnabled: true
  # 文件路径 示例（ Windows配置D:/vcsrm/uploadPath，Linux配置 /home/vcsrm/uploadPath）
  profile: /home/vcsrm/uploadPath
  # 获取ip地址开关
  addressEnabled: true

java类：

 

import java.io.FileNotFoundException;
import java.util.HashMap;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.xx.common.utils.StringUtils;
import com.xx.common.utils.YamlUtil;

/**
 * 全局配置类
 * 
 * @author xx
 */
public class Global
{
    private static final Logger log = LoggerFactory.getLogger(Global.class);

    private static String NAME = "application.yml";

    /**
     * 当前对象实例
     */
    private static Global global;

    /**
     * 保存全局属性值
     */
    private static Map<String, String> map = new HashMap<String, String>();

    private Global()
    {
    }

    /**
     * 静态工厂方法
     */
    public static synchronized Global getInstance()
    {
        if (global == null)
        {
            global = new Global();
        }
        return global;
    }

    /**
     * 获取配置
     */
    public static String getConfig(String key)
    {
        String value = map.get(key);
        if (value == null)
        {
            Map<?, ?> yamlMap = null;
            try
            {
                yamlMap = YamlUtil.loadYaml(NAME);
                value = String.valueOf(YamlUtil.getProperty(yamlMap, key));
                map.put(key, value != null ? value : StringUtils.EMPTY);
            }
            catch (FileNotFoundException e)
            {
                log.error("获取全局配置异常 {}", key);
            }
        }
        return value;
    }

    /**
     * 获取项目名称
     */
    public static String getName()
    {
        return StringUtils.nvl(getConfig("vcsrm.name"), "RuoYi");
    }

    /**
     * 获取项目版本
     */
    public static String getVersion()
    {
        return StringUtils.nvl(getConfig("vcsrm.version"), "4.0.0");
    }

    /**
     * 获取版权年份
     */
    public static String getCopyrightYear()
    {
        return StringUtils.nvl(getConfig("vcsrm.copyrightYear"), "2019");
    }

    /**
     * 实例演示开关
     */
    public static String isDemoEnabled()
    {
        return StringUtils.nvl(getConfig("vcsrm.demoEnabled"), "true");
    }

    /**
     * 获取ip地址开关
     */
    public static Boolean isAddressEnabled()
    {
        return Boolean.valueOf(getConfig("vcsrm.addressEnabled"));
    }

    /**
     * 获取文件上传路径
     */
    public static String getProfile()
    {
        return getConfig("vcsrm.profile");
    }

    /**
     * 获取头像上传路径
     */
    public static String getAvatarPath()
    {
        return getProfile() + "/avatar";
    }

    /**
     * 获取下载路径
     */
    public static String getDownloadPath()
    {
        return getProfile() + "/download/";
    }

    /**
     * 获取上传路径
     */
    public static String getUploadPath()
    {
        return getProfile() + "/upload";
    }
}

yaml文件操作工具类：

import org.yaml.snakeyaml.DumperOptions;
import org.yaml.snakeyaml.Yaml;

import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * 配置处理工具类
 * 
 * @author yml
 */
public class YamlUtil
{
    public static Map<?, ?> loadYaml(String fileName) throws FileNotFoundException
    {
        InputStream in = YamlUtil.class.getClassLoader().getResourceAsStream(fileName);
        return StringUtils.isNotEmpty(fileName) ? (LinkedHashMap<?, ?>) new Yaml().load(in) : null;
    }

    public static void dumpYaml(String fileName, Map<?, ?> map) throws IOException
    {
        if (StringUtils.isNotEmpty(fileName))
        {
            FileWriter fileWriter = new FileWriter(YamlUtil.class.getResource(fileName).getFile());
            DumperOptions options = new DumperOptions();
            options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
            Yaml yaml = new Yaml(options);
            yaml.dump(map, fileWriter);
        }
    }

    public static Object getProperty(Map<?, ?> map, Object qualifiedKey)
    {
        if (map != null && !map.isEmpty() && qualifiedKey != null)
        {
            String input = String.valueOf(qualifiedKey);
            if (!"".equals(input))
            {
                if (input.contains("."))
                {
                    int index = input.indexOf(".");
                    String left = input.substring(0, index);
                    String right = input.substring(index + 1, input.length());
                    return getProperty((Map<?, ?>) map.get(left), right);
                }
                else if (map.containsKey(input))
                {
                    return map.get(input);
                }
                else
                {
                    return null;
                }
            }
        }
        return null;
    }

    @SuppressWarnings("unchecked")
    public static void setProperty(Map<?, ?> map, Object qualifiedKey, Object value)
    {
        if (map != null && !map.isEmpty() && qualifiedKey != null)
        {
            String input = String.valueOf(qualifiedKey);
            if (!input.equals(""))
            {
                if (input.contains("."))
                {
                    int index = input.indexOf(".");
                    String left = input.substring(0, index);
                    String right = input.substring(index + 1, input.length());
                    setProperty((Map<?, ?>) map.get(left), right, value);
                }
                else
                {
                    ((Map<Object, Object>) map).put(qualifiedKey, value);
                }
            }
        }
    }
}

需要引入：

<!-- yml解析器 -->
<dependency>
    <groupId>org.yaml</groupId>
    <artifactId>snakeyaml</artifactId>
</dependency>