Java以IO流和文件流，生成、下载二维码

chenchenchen

发布于 2022-03-09 13:07:27

2.1K0

发布于 2022-03-09 13:07:27

文章被收录于专栏：chenchenchen

场景

在系统中生成一个二维码，用户保存下来并分享出去，其他人扫描之后跳到我们的一个活动详情页，查看此活动的内容。

从以上的需求中，可以提炼出以下几点：

当用户点击生成二维码的时候，我们要拿到用户生成的二维码是关于哪个活动的；
请求来到后台，拿到活动ID，作为我们活动详情页的参数，生成一个url，作为扫描之后的跳转地址，生成二维码；
把生成的二维码，返回给前端，展示给用户；
用户保存二维码，即下载下来。

需求就是给二维码设置内容并展示在前端。二维码的内容，可以是一段明文，也可以是一个http或https链接，当扫描时会自动访问这个链接。

实现

重点分析第三步和第四步，即二维码的生成和用户下载二维码。

怎样生成二维码，市面上有很多依赖包，拿来用就行，重点是如何优雅地返回给用户以及供其下载。其实让用户下载这个动作，也不是很必要，毕竟大多数年轻人都知道长按保存，但还是要照顾一下其他的用户，给出明显的下载按钮。

先说第三步，二维码如何返回给前端？也许很多人会想到，把生成的二维码存到服务器上，再把图片路径返回不就行了？这样当然可以，但是却多了很多不必要的操作：

对于二维码，我们只需要返回给用户即可，并不需要存到我们的服务器上，这没有任何意义，还占用磁盘空间；

如果将二维码写到服务器，就需要跟磁盘IO打交道，这是昂贵的代价；

每一个用户生成的二维码，都对应一个URL，很乱

我们可以直接将生成的二维码图片，以IO流的方式，通过response响应体直接返回给请求方。第一，不需要落到我们的磁盘，一切操作都在内存中完成，效率比较高；第二，所有生成二维码的请求，都可以访问这里，前端直接拿img标签的src就能访问，你在浏览器直接输入这个路径也能得到一张图片，减少了很多交互和逻辑处理。

再说第四步，我们直接在前端实现，因为前端有一种机制可以将某个img标签的图片下载下来，不需要浪费我们的服务器。

第一步——引入依赖

需要引入两个依赖包：

<dependency>
            <groupId>com.google.zxing</groupId>
            <artifactId>core</artifactId>
            <version>3.0.0</version>
        </dependency>
        <dependency>
            <groupId>com.google.zxing</groupId>
            <artifactId>javase</artifactId>
            <version>3.0.0</version>
        </dependency>

编写工具类

package com.dosion.utils;
 
 
import com.google.zxing.BarcodeFormat;
import com.google.zxing.EncodeHintType;
import com.google.zxing.MultiFormatWriter;
import com.google.zxing.WriterException;
import com.google.zxing.client.j2se.MatrixToImageWriter;
import com.google.zxing.common.BitMatrix;
import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;
 
 
import java.io.File;
import java.io.IOException;
import java.net.URLDecoder;
import java.util.HashMap;
import java.util.Map;
 
/**
 *  <p>
 *      生成二维码的工具类
 *  </p>
 * */
public class QRCodeUtils {
 
    /**
     *  生成二维码并以IO流的形式返回给前端展示
     * @param content 二维码的内容
     * @param width 二维码的宽
     * @param height 二维码的高
     * @return BitMatrix对象
     * */
    public static BitMatrix createCode(String content,int width,int height) throws IOException {

        //其他参数，如字符集编码
        Map<EncodeHintType, Object> hints = new HashMap<EncodeHintType, Object>();
        hints.put(EncodeHintType.CHARACTER_SET, "UTF-8");
        //容错级别为H
        hints.put(EncodeHintType.ERROR_CORRECTION , ErrorCorrectionLevel.H);
        //白边的宽度，可取0~4
        hints.put(EncodeHintType.MARGIN , 0);

        BitMatrix bitMatrix = null;
        try {
            //生成矩阵，因为我的业务场景传来的是编码之后的URL，所以先解码
            bitMatrix = new MultiFormatWriter().encode(content,
                    BarcodeFormat.QR_CODE, width, height, hints);

            //bitMatrix = deleteWhite(bitMatrix);
        } catch (WriterException e) {
            e.printStackTrace();
        }

        return bitMatrix;
    }
 
    /**
     *  删除生成的二维码周围的白边，根据审美决定是否删除
     * @param matrix BitMatrix对象
     * @return BitMatrix对象
     * */
    private static BitMatrix deleteWhite(BitMatrix matrix) {
        int[] rec = matrix.getEnclosingRectangle();
        int resWidth = rec[2] + 1;
        int resHeight = rec[3] + 1;
 
        BitMatrix resMatrix = new BitMatrix(resWidth, resHeight);
        resMatrix.clear();
        for (int i = 0; i < resWidth; i++) {
            for (int j = 0; j < resHeight; j++) {
                if (matrix.get(i + rec[0], j + rec[1]))
                    resMatrix.set(i, j);
            }
        }
        return resMatrix;
    }


    /**
     *  下载二维码
     * @param content 二维码的内容
     * @param width 二维码的宽
     * @param height 二维码的高
     * @return BitMatrix对象
     * */
    public static BitMatrix dowanload(String content,int width,int height) throws Exception {

        Map<EncodeHintType, Object> hints = new HashMap<EncodeHintType, Object>();
        // 指定编码格式
        hints.put(EncodeHintType.CHARACTER_SET, "UTF-8");
        // 指定纠错级别(L--7%,M--15%,Q--25%,H--30%)
        hints.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.H);
        // 编码内容,编码类型(这里指定为二维码),生成图片宽度,生成图片高度,设置参数
        BitMatrix bitMatrix = new MultiFormatWriter().encode(content, BarcodeFormat.QR_CODE, width, height, hints);
        return bitMatrix;
    }

}

编写API接口

    /**
     *  生成二维码
     * */
    @GetMapping(value = "/qrcode/create")
    public void getCode(@RequestParam("content") String content , HttpServletResponse response) throws IOException {
        // 设置响应流信息
        response.setContentType("image/jpg");
        response.setHeader("Pragma", "no-cache");
        response.setHeader("Cache-Control", "no-cache");
        response.setDateHeader("Expires", 0);

        OutputStream stream = response.getOutputStream();

        //二维码的宽高
        int width = 200;
        int height = 200;

        //获取一个二维码图片
        BitMatrix bitMatrix = QRCodeUtils.createCode(content,width,height);
        //以流的形式输出到前端
        MatrixToImageWriter.writeToStream(bitMatrix , "jpg" , stream);
    }

    @GetMapping("/qrcode/dowanload")
    public void dowanload(@RequestParam("content") String content ,
                          HttpServletRequest request, HttpServletResponse response) throws Exception {
        //二维码的宽高
        int width = 200;
        int height = 200;

        BitMatrix bitMatrix = QRCodeUtils.dowanload(content,width,height);
        //设置请求头
        response.setHeader("Content-Type","application/octet-stream");
        response.setHeader("Content-Disposition", "attachment;filename=" + "二维码.png");
        OutputStream outputStream = response.getOutputStream();
        MatrixToImageWriter.writeToStream(bitMatrix, "png", outputStream);
        outputStream.flush();
        outputStream.close();
    }

访问测试

扫描以上二维码就会显示content内容

下载图片

用法也很简单，imgSrc就是图片的地址，在这里指向我们上面的API就行，因为我们的API响应的就是一张图片嘛。name就是下载之后的文件名。

function downloadImage(imgsrc, name) {//下载图片地址和图片名
                let image = new Image();
                // 解决跨域 Canvas 污染问题
                image.setAttribute("crossOrigin", "anonymous");
                image.onload = function() {
                    let canvas = document.createElement("canvas");
                    canvas.width = image.width;
                    canvas.height = image.height;
                    let context = canvas.getContext("2d");
                    context.drawImage(image, 0, 0, image.width, image.height);
                    let url = canvas.toDataURL("image/jpg"); //得到图片的base64编码数据
                    let a = document.createElement("a"); // 生成一个a元素
                    let event = new MouseEvent("click"); // 创建一个单击事件
                    a.download = name || "photo"; // 设置图片名称
                    a.href = url; // 将生成的URL设置为a.href属性
                    a.dispatchEvent(event); // 触发a的单击事件
                };
                image.src = imgsrc;
            }

生成和解析二维码，支持图片和输出流，支持添加logo图片

import java.awt.BasicStroke;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Shape;
import java.awt.geom.RoundRectangle2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.OutputStream;
import java.util.Hashtable;
import java.util.Random;

import javax.imageio.ImageIO;

import com.google.zxing.BarcodeFormat;
import com.google.zxing.BinaryBitmap;
import com.google.zxing.DecodeHintType;
import com.google.zxing.EncodeHintType;
import com.google.zxing.MultiFormatReader;
import com.google.zxing.MultiFormatWriter;
import com.google.zxing.Result;
import com.google.zxing.client.j2se.BufferedImageLuminanceSource;
import com.google.zxing.common.BitMatrix;
import com.google.zxing.common.HybridBinarizer;
import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;

public class QRCodeUtils {
    private static final String CHARSET = "utf-8";
    private static final String FORMAT_NAME = "JPG";
    // 二维码尺寸    
    private static final int QRCODE_SIZE = 300;
    // LOGO宽度    
    private static final int WIDTH = 60;
    // LOGO高度    
    private static final int HEIGHT = 60;

    private static BufferedImage createImage(String content, String imgPath,
                                             boolean needCompress) throws Exception {
        Hashtable<EncodeHintType, Object> hints = new Hashtable<EncodeHintType, Object>();
        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)) {
            return image;
        }
        // 插入图片    
        QRCodeUtils.insertImage(image, imgPath, needCompress);
        return image;
    }

    /**
     * 插入LOGO  
     *
     * @param source
     *            二维码图片  
     * @param imgPath
     *            LOGO图片地址  
     * @param needCompress
     *            是否压缩  
     * @throws Exception
     */
    private static void insertImage(BufferedImage source, String imgPath,
                                    boolean needCompress) throws Exception {
        File file = new File(imgPath);
        if (!file.exists()) {
            System.err.println(""+imgPath+"   该文件不存在！");
            return;
        }
        Image src = ImageIO.read(new File(imgPath));
        int width = src.getWidth(null);
        int height = src.getHeight(null);
        if (needCompress) { // 压缩LOGO    
            if (width > WIDTH) {
                width = WIDTH;
            }
            if (height > HEIGHT) {
                height = 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  
     * @throws Exception
     */
    public static String encode(String content, String imgPath, String destPath,
                              boolean needCompress) throws Exception {
        BufferedImage image = QRCodeUtils.createImage(content, imgPath,
                needCompress);
        mkdirs(destPath);
        String file = new Random().nextInt(99999999)+".jpg";
        ImageIO.write(image, FORMAT_NAME, new File(destPath+"/"+file));
        return file;
    }

    /**
     * 当文件夹不存在时，mkdirs会自动创建多层目录，区别于mkdir．(mkdir如果父目录不存在则会抛出异常)  
     * @date 2013-12-11 上午10:16:36  
     * @param destPath 存放目录  
     */
    public static void mkdirs(String destPath) {
        File file =new File(destPath);
        //当文件夹不存在时，mkdirs会自动创建多层目录，区别于mkdir．(mkdir如果父目录不存在则会抛出异常)    
        if (!file.exists() && !file.isDirectory()) {
            file.mkdirs();
        }
    }

    /**
     * 生成二维码(内嵌LOGO)  
     *
     * @param content
     *            内容  
     * @param imgPath
     *            LOGO地址  
     * @param destPath
     *            存储地址  
     * @throws Exception
     */
    public static void encode(String content, String imgPath, String destPath)
            throws Exception {
        QRCodeUtils.encode(content, imgPath, destPath, false);
    }

    /**
     * 生成二维码  
     *
     * @param content
     *            内容  
     * @param destPath
     *            存储地址  
     * @param needCompress
     *            是否压缩LOGO  
     * @throws Exception
     */
    public static void encode(String content, String destPath,
                              boolean needCompress) throws Exception {
        QRCodeUtils.encode(content, null, destPath, needCompress);
    }

    /**
     * 生成二维码  
     *
     * @param content
     *            内容  
     * @param destPath
     *            存储地址  
     * @throws Exception
     */
    public static void encode(String content, String destPath) throws Exception {
        QRCodeUtils.encode(content, null, destPath, false);
    }

    /**
     * 生成二维码(内嵌LOGO)  
     *
     * @param content
     *            内容  
     * @param imgPath
     *            LOGO地址  
     * @param output
     *            输出流  
     * @param needCompress
     *            是否压缩LOGO  
     * @throws Exception
     */
    public static void encode(String content, String imgPath,
                              OutputStream output, boolean needCompress) throws Exception {
        BufferedImage image = QRCodeUtils.createImage(content, imgPath,
                needCompress);
        ImageIO.write(image, FORMAT_NAME, output);
    }

    /**
     * 生成二维码  
     *
     * @param content
     *            内容  
     * @param output
     *            输出流  
     * @throws Exception
     */
    public static void encode(String content, OutputStream output)
            throws Exception {
        QRCodeUtils.encode(content, null, output, false);
    }

    /**
     * 解析二维码  
     *
     * @param file
     *            二维码图片  
     * @return
     * @throws Exception
     */
    public static 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<DecodeHintType, Object> hints = new Hashtable<DecodeHintType, Object>();
        hints.put(DecodeHintType.CHARACTER_SET, CHARSET);
        result = new MultiFormatReader().decode(bitmap, hints);
        String resultStr = result.getText();
        return resultStr;
    }

    /**
     * 解析二维码  
     *
     * @param path
     *            二维码图片地址  
     * @return
     * @throws Exception
     */
    public static String decode(String path) throws Exception {
        return QRCodeUtils.decode(new File(path));
    }

    public static void main(String[] args) throws Exception {
        String text = "http://www.baidu.com";  //这里设置自定义网站url
        String logoPath = "C:\\Users\\admin\\Desktop\\test\\test.jpg";
        String destPath = "C:\\Users\\admin\\Desktop\\test\\";
        System.out.println(QRCodeUtils.encode(text, logoPath, destPath, true));
    }
}

参考：

Java生成二维码并以IO流的形式返回给前端展示(不需写入服务器)，以及下载二维码图片：https://blog.csdn.net/wzy18210825916/article/details/100037429

java 生成二维码并以流形式输出显示到页面上：http://www.manongjc.com/article/18411.html

java生成二维码技术实现：https://www.jianshu.com/p/bb76ded47d64

利用java生成二维码工具类示例代码：https://www.jb51.net/article/123311.htm

Java生成和解析二维码，支持图片和输出流，支持添加logo图片：https://blog.csdn.net/jinqilin721/article/details/88894682

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

如有侵权请联系 cloudcommunity@tencent.com 删除

网站