Java
二维码在目前的生活工作中，随处可见，日常开发中难免会遇到需要生成二维码的场景，网上也有很多开源的平台可以使用，不过这里可以通过几个开源组件，自己来实现一下。
在动手之前先思考一下需要进行的操作，首先需要生成一个二维码，其次需要在这里二维码中间添加一个头像。这里生成二维码使用工具 zxing，合成图片采用 thumbnailator，接下来实际操一下吧。

生成二维码

首先先根据目标地址，生成一个二维码，这里使用的是组件 zxing，在 SpringBoot 的pom依赖中，加入下面的依赖。

  1. <dependency>
  2.     <groupId>com.google.zxing</groupId>
  3.     <artifactId>core</artifactId>
  4.     <version>3.4.0</version>
  5. </dependency>
  6. <dependency>
  7.     <groupId>com.google.zxing</groupId>
  8.     <artifactId>javase</artifactId>
  9.     <version>3.4.0</version>
  10. </dependency>

然后编写工具类 QRCodeGenerator.java

  1. import com.google.zxing.BarcodeFormat;
  2. import com.google.zxing.EncodeHintType;
  3. import com.google.zxing.MultiFormatWriter;
  4. import com.google.zxing.WriterException;
  5. import com.google.zxing.client.j2se.MatrixToImageWriter;
  6. import com.google.zxing.common.BitMatrix;
  8. import java.io.IOException;
  9. import java.nio.file.FileSystems;
  10. import java.nio.file.Path;
  11. import java.util.HashMap;
  14. public class QRCodeGenerator {
  16.   /**
  17.    * 根据内容，大小生成二维码到指定路径
  18.    *
  19.    * @param contents 跳转的链接
  20.    * @param width    宽度
  21.    * @param height   高度
  22.    * @param filePath 路径
  23.    * @throws WriterException
  24.    * @throws IOException
  25.    */
  26.   public static void generateQrWithImage(String contents, int width, int height, String filePath) throws WriterException, IOException {
  27.     //构造二维码写码器
  28.     MultiFormatWriter mutiWriter = new com.google.zxing.MultiFormatWriter();
  29.     HashMap<EncodeHintType, Object> hint = new HashMap<>(16);
  30.     hint.put(EncodeHintType.CHARACTER_SET, "UTF-8");
  31.     hint.put(EncodeHintType.ERROR_CORRECTION, com.google.zxing.qrcode.decoder.ErrorCorrectionLevel.H);
  32.     hint.put(EncodeHintType.MARGIN, 1);
  33.     //生成二维码
  34.     BitMatrix bitMatrix = mutiWriter.encode(contents, BarcodeFormat.QR_CODE, width, height, hint);
  35.     Path path = FileSystems.getDefault().getPath(filePath);
  36.     MatrixToImageWriter.writeToPath(bitMatrix, "jpeg", path);
  37.   }
  38. }

这个静态方法有四个参数，分别是：

  1. 跳转的链接内容；
  2. 二维码的宽度；
  3. 二维码的高度；
  4. 生成的二维码后的存放路径；

代码中还有几个常量，EncodeHintType.CHARACTER_SET：表示编码；EncodeHintType.ERROR_CORRECTION 表示二维码的容错率；EncodeHintType.MARGIN 表示二维码的边框。
解释一下什么是二维码的容错率，大家在日常生活或者工作中应该会发现，有些二维码轻轻一扫就扫成功了，有的二维码却很难扫成功，这背后就是二维码的容错率的原因（对，有时候并不是网络问题！）。

不同密度的二维码所包含的信息其编码的字符、容错率均不同。密度越低，编码的字符个数越少、容错率越低，二维码容错率表示二维码图标被遮挡多少后，仍可以被扫描出来的能力。目前，典型的二维码的容错率分为 7%、15%、25%、30% 四个等级，容错率越高，越容易被快速扫描。“但是，容错率越高，二维码里面的黑白格子也就越多。因此，对于目前主流手机，在绝大多数扫描场景下，仍普遍应用 7% 容错率的二维码就能满足需求。

感兴趣的小伙伴也可以自己尝试几个不同的容错率，看看扫码的难度有没有变化。
接下来，编写一个 main 方法来生成一个二维码

  1. public static void main(String[] args) {
  2.     try {
  3.       QRCodeGenerator.generateQrWithImage("https://www.yuque.com/fcant/java", 500, 500, "./QRCode.jpeg");
  4.     } catch (Exception e) {
  5.     }
  6.   }

QRCode.jpeg
运行完上面的 main 方法，可以得到一个二维码，到这里第一步已经完成了，接下来就是给这个二维码加上头像。

添加头像

添加头像需要准备一个头像的照片，如果这里有现成大小的头像就直接拿来使用就行，如果没有也没有关系，可以自己裁剪，这里就需要用来图片处理工具 thumbnailator 了。
首先引入依赖

  1. <dependency>
  2.     <groupId>net.coobird</groupId>
  3.     <artifactId>thumbnailator</artifactId>
  4.     <version>0.4.8</version>
  5. </dependency>

home_wallpaper_0.jpg
先将头像处理成 100 x 100 的大小，然后再合成上去就行，代码如下：

  1. public static void main(String[] args) {
  2.     try {
  3.       // 将大图片缩小到指定大小
  4. //    ThumbnailsImageUtils.size("./photo.jpeg", 100, 100, 1, "./photo100.png");
  5.       // 通过水印的形式，将头像加到生成的二维码上面
  6.       ThumbnailsImageUtils.watermark("./QRCode.jpeg",
  7.       500, 500, Positions.CENTER, "./photo100.png",
  8.         1f, 1f, "./result.png");
  9.     } catch (Exception e) {
  10.     }
  11. }

result.png
这个就是最终生成的带头像的二维码了，通过上面的代码可以看到，ThumbnailsImageUtils 是真的很多强大，一行代码就能搞定图片缩小和图片合成，更多关于 ThumbnailsImageUtils 工具类的完整代码如下，赶紧收藏起来。

  1. import net.coobird.thumbnailator.Thumbnails;
  2. import net.coobird.thumbnailator.geometry.Positions;
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  6. import javax.imageio.ImageIO;
  7. import java.awt.*;
  8. import java.awt.image.BufferedImage;
  9. import java.io.File;
  10. import java.io.FileOutputStream;
  11. import java.io.IOException;
  12. import java.io.OutputStream;
  14. /**
  15. * <br>
  16. * <b>功能：</b><br>
  17. * <b>作者：</b>@author ziyou<br>
  18. * <b>日期：</b>2018-05-25 16:17<br>
  19. * <b>详细说明：</b>使用google开源工具Thumbnailator实现图片的一系列处理<br>
  20. */
  21. public class ThumbnailsImageUtils {
  23.     private final static Logger logger = LoggerFactory.getLogger(ThumbnailsImageUtils.class);
  25.     /**
  26.     * 将原图根据指定大小生产新图
  27.     *
  28.     * @param sourceFilePath 原始图片路径
  29.     * @param width          指定图片宽度
  30.     * @param height         指定图片高度
  31.     * @param targetFilePath 目标图片路径
  32.     * @return 目标图片路径
  33.     * @throws IOException
  34.     */
  35.     public static String thumb(String sourceFilePath, Integer width, Integer height, String targetFilePath) throws IOException {
  36.         Thumbnails.of(sourceFilePath)
  37.             .forceSize(width, height)
  38.             .toFile(targetFilePath);
  39.         return targetFilePath;
  40.     }
  43.     /**
  44.     * 按照比例进行缩放
  45.     *
  46.     * @param sourceFilePath 原始图片路径
  47.     * @param scale          scale(比例)
  48.     * @param targetFilePath 目标图片路径
  49.     * @return 目标图片路径
  50.     * @throws IOException
  51.     */
  52.     public static String scale(String sourceFilePath, Double scale, String targetFilePath) throws IOException {
  53.         Thumbnails.of(sourceFilePath)
  54.             .scale(scale)
  55.             .toFile(targetFilePath);
  56.         return targetFilePath;
  57.     }
  60.     /**
  61.     * 不按照比例，指定大小进行缩放
  62.     *
  63.     * @param sourceFilePath 原始图片路径
  64.     * @param width          指定图片宽度
  65.     * @param height         指定图片高度
  66.     * @param targetFilePath 目标图片路径
  67.     *                       keepAspectRatio(false) 默认是按照比例缩放的
  68.     * @return 目标图片路径
  69.     * @throws IOException
  70.     */
  71.     public static String size(String sourceFilePath, Integer width, Integer height, float quality, String targetFilePath) throws IOException {
  72.         Thumbnails.of(sourceFilePath)
  73.             .size(width, height)
  74.             .outputQuality(quality)
  75.             .keepAspectRatio(false)
  76.             .toFile(targetFilePath);
  77.         return targetFilePath;
  78.     }
  81.     /**
  82.     * 指定大小和角度旋转
  83.     *
  84.     * @param sourceFilePath 原始图片路径
  85.     * @param width          指定图片宽度
  86.     * @param height         指定图片高度
  87.     * @param rotate         rotate(角度),正数：顺时针 负数：逆时针
  88.     * @param targetFilePath 目标图片路径
  89.     * @return 目标图片路径
  90.     * @throws IOException
  91.     */
  92.     public static String rotate(String sourceFilePath, Integer width, Integer height, Double rotate, String targetFilePath) throws IOException {
  93.         Thumbnails.of(sourceFilePath)
  94.             .size(width, height)
  95.             .rotate(rotate)
  96.             .toFile(targetFilePath);
  97.         return targetFilePath;
  98.     }
  101.     /**
  102.     * 指定角度旋转
  103.     *
  104.     * @param sourceFilePath 原始图片路径
  105.     * @param rotate         rotate(角度),正数：顺时针 负数：逆时针
  106.     * @param targetFilePath 目标图片路径
  107.     * @return 目标图片路径
  108.     * @throws IOException
  109.     */
  110.     public static String rotate(String sourceFilePath, Double rotate, String targetFilePath) throws IOException {
  111.         Thumbnails.of(sourceFilePath)
  112.             .rotate(rotate)
  113.             .toFile(targetFilePath);
  114.         return targetFilePath;
  115.     }
  118.     /**
  119.     * @param sourceFilePath 原始图片路径
  120.     * @param width          指定图片宽度
  121.     * @param height         指定图片高度
  122.     * @param position       水印位置
  123.     * @param waterFile      水印文件
  124.     * @param opacity        水印透明度
  125.     * @param quality        输出文件的质量
  126.     * @param targetFilePath 目标图片路径
  127.     * @return 目标图片路径
  128.     * @throws IOException
  129.     */
  130.     public static String watermark(String sourceFilePath, Integer width, Integer height, Positions position, String waterFile, float opacity, float quality, String targetFilePath) throws IOException {
  131.         Thumbnails.of(sourceFilePath)
  132.             .size(width, height)
  133.             .watermark(position, ImageIO.read(new File(waterFile)), opacity)
  134.             .outputQuality(quality)
  135.             .toFile(targetFilePath);
  136.         return targetFilePath;
  137.     }
  140.     public static BufferedImage watermarkList(BufferedImage buffImg, int length, File[] waterFileArray) throws IOException {
  141.         int x = 0;
  142.         int y = 0;
  143.         if (buffImg == null) {
  144.             // 获取底图
  145.             buffImg = new BufferedImage(1200, 1200, BufferedImage.SCALE_SMOOTH);
  146.         } else {
  147.             x = (length % 30) * 40;
  148.             y = (length / 30) * 40;
  149.         }
  150.         // 创建Graphics2D对象，用在底图对象上绘图
  151.         Graphics2D g2d = buffImg.createGraphics();
  152.         // 将图像填充为白色
  153.         g2d.setColor(Color.WHITE);
  154.         g2d.fillRect(x, y, 1200, 40 * (waterFileArray.length + length));
  155.         for (int i = 0; i < waterFileArray.length; i++) {
  156.             // 获取层图
  157.             BufferedImage waterImg = ImageIO.read(waterFileArray[i]);
  158.             // 获取层图的宽度
  159.             int waterImgWidth = waterImg.getWidth();
  160.             // 获取层图的高度
  161.             int waterImgHeight = waterImg.getHeight();
  162.             // 在图形和图像中实现混合和透明效果
  163.             g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, 1));
  164.             // 绘制
  165.             Integer j = i / 30;
  166.             Integer index = i - j * 30;
  167.             g2d.drawImage(waterImg, waterImgWidth * index + 1, waterImgHeight * j, waterImgWidth, waterImgHeight, null);
  169.         }
  171.         // 释放图形上下文使用的系统资源
  172.         g2d.dispose();
  173.         return buffImg;
  174.     }
  176.     /**
  177.     * @param sourceFilePath 原始图片路径
  178.     * @param waterFile      水印文件
  179.     * @param targetFilePath 目标图片路径
  180.     *                       透明度默认值0.5f，质量默认0.8f
  181.     * @return 目标图片路径
  182.     * @throws IOException
  183.     */
  184.     public static String watermark(String sourceFilePath, String waterFile, String targetFilePath) throws IOException {
  185.         Image image = ImageIO.read(new File(waterFile));
  186.         Integer width = image.getWidth(null);
  187.         Integer height = image.getHeight(null);
  188.         return watermark(sourceFilePath, width, height,
  189.                          Positions.BOTTOM_RIGHT, waterFile, 0.5f, 0.8f, targetFilePath);
  190.     }
  193.     /**
  194.     * 将图片转化为指定大小和格式的图片
  195.     *
  196.     * @param sourceFilePath
  197.     * @param width
  198.     * @param height
  199.     * @param format
  200.     * @param targetFilePath
  201.     * @return
  202.     * @throws IOException
  203.     */
  204.     public static String changeFormat(String sourceFilePath, Integer width, Integer height, String format, String targetFilePath) throws IOException {
  205.         Thumbnails.of(sourceFilePath)
  206.             .size(width, height)
  207.             .outputQuality(0.8f)
  208.             .outputFormat(format)
  209.             .toFile(targetFilePath);
  210.         return targetFilePath;
  211.     }
  214.     /**
  215.     * 根据原大小转化指定格式
  216.     *
  217.     * @param sourceFilePath
  218.     * @param format
  219.     * @param targetFilePath
  220.     * @return
  221.     * @throws IOException
  222.     */
  223.     public static String changeFormat(String sourceFilePath, String format, String targetFilePath) throws IOException {
  224.         Image image = ImageIO.read(new File(sourceFilePath));
  225.         Integer width = image.getWidth(null);
  226.         Integer height = image.getHeight(null);
  227.         Thumbnails.of(sourceFilePath)
  228.             .size(width, height)
  229.             .outputFormat(format)
  230.             .toFile(targetFilePath);
  231.         return targetFilePath;
  232.     }
  234.     /**
  235.     * 输出到输出流
  236.     *
  237.     * @param sourceFilePath
  238.     * @param targetFilePath
  239.     * @return
  240.     * @throws IOException
  241.     */
  242.     public static String toOutputStream(String sourceFilePath, String targetFilePath) throws IOException {
  243.         OutputStream os = new FileOutputStream(targetFilePath);
  244.         Thumbnails.of(sourceFilePath).toOutputStream(os);
  245.         return targetFilePath;
  246.     }
  249.     /**
  250.     * 输出到BufferedImage
  251.     *
  252.     * @param sourceFilePath
  253.     * @param format
  254.     * @param targetFilePath
  255.     * @return
  256.     * @throws IOException
  257.     */
  258.     public static String asBufferedImage(String sourceFilePath, String format, String targetFilePath) throws IOException {
  259.         /**
  260.         * asBufferedImage() 返回BufferedImage
  261.         */
  262.         BufferedImage thumbnail = Thumbnails.of(sourceFilePath).size(1280, 1024).asBufferedImage();
  263.         ImageIO.write(thumbnail, format, new File(targetFilePath));
  264.         return targetFilePath;
  265.     }
  266. }