JAVA使用barcode4j生成条形码和二维码图片以及带logo的二维码，验证码图片，使用thumbnailator压缩图片和加水印

一、二维码

1.Maven引入barcode4j依赖

<!-- 条形码生成 -->
        <dependency>
            <groupId>net.sf.barcode4j</groupId>
            <artifactId>barcode4j</artifactId>
            <version>2.1</version>
        </dependency>
<!-- https://mvnrepository.com/artifact/org.apache.avalon.framework/avalon-framework-api -->
        <dependency>
            <groupId>org.apache.avalon.framework</groupId>
            <artifactId>avalon-framework-api</artifactId>
            <version>4.3.1</version>
        </dependency>

2.工具类

package com.wulianwang.manage.utils.util;

import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.configuration.DefaultConfiguration;
import org.apache.commons.io.FileUtils;
import org.krysalis.barcode4j.BarcodeException;
import org.krysalis.barcode4j.BarcodeGenerator;
import org.krysalis.barcode4j.BarcodeUtil;
import org.krysalis.barcode4j.HumanReadablePlacement;
import org.krysalis.barcode4j.impl.code128.Code128Bean;
import org.krysalis.barcode4j.output.bitmap.BitmapCanvasProvider;

import java.awt.image.BufferedImage;
import java.io.*;


/**
 * 条形码工具类
 */
public class BarCodeUtils {

/**************************** 条形码  ********************************/
/**
     * 生成code128条形码
     *
     * @param message       要生成的文本
     * @param withQuietZone 是否两边留白
     * @param hideText      隐藏可读文本
     * @param filePath      文件生成的路径
     */

public static void generateBarCode128(String message, boolean withQuietZone, boolean hideText, String filePath) {
        Code128Bean bean = new Code128Bean();
        // 分辨率
        int dpi = 512;
 // 设置两侧是否留白
        bean.doQuietZone(withQuietZone);

        // 设置条形码高度和宽度(不填就是默认的)
//        bean.setBarHeight((double) ObjectUtils.defaultIfNull(height, 9.0D));
//        if (width != null) {
//            bean.setModuleWidth(width);
//        }
        // 设置文本位置（包括是否显示）
    if (hideText) {
            bean.setMsgPosition(HumanReadablePlacement.HRP_NONE);
        }
        // 设置图片类型
        String format = "image/png";
ByteArrayOutputStream ous = new ByteArrayOutputStream();
        BitmapCanvasProvider canvas = new BitmapCanvasProvider(ous, format, dpi,
                BufferedImage.TYPE_BYTE_BINARY, false, 0);

        // 生产条形码
        bean.generateBarcode(canvas, message);
try {
            canvas.finish();
            //字节码
            byte[] bytes = ous.toByteArray();
            FileUtils.writeByteArrayToFile(new File(filePath), bytes);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

 /**************************** 二维码  ********************************/
    /**
     * 生成二维码
     * @param message       要生成的文本
     * @param filePath      文件生成的路径
     */
    public static void genQRCode(String message, String filePath){

try {
            BarcodeUtil util = BarcodeUtil.getInstance();
            DefaultConfiguration cfg = new DefaultConfiguration("barcode");
            // Bar code type
            DefaultConfiguration child = new DefaultConfiguration("datamatrix");
            cfg.addChild(child);

// Human readable text position
            DefaultConfiguration attr = new DefaultConfiguration("human-readable");
//        //设置高度(无效果)
//        attr = new DefaultConfiguration("height");
//        attr.setValue(50);
//        child.addChild(attr);
           //设置二维码宽度
            attr = new DefaultConfiguration("module-width");
            attr.setValue("2.0");
            child.addChild(attr);
            BarcodeGenerator gen = util.createBarcodeGenerator(cfg);
            //分辨率
            int resolution = 300;
            // 设置图片类型
            String format = "image/png";
            ByteArrayOutputStream ous = new ByteArrayOutputStream();
            BitmapCanvasProvider canvas = new BitmapCanvasProvider(ous, format, resolution,
                    BufferedImage.TYPE_BYTE_BINARY, false, 0);

            gen.generateBarcode(canvas, message);
            canvas.finish();
            //字节码
            byte[] bytes = ous.toByteArray();
            FileUtils.writeByteArrayToFile(new File(filePath), bytes);
        } catch (ConfigurationException e) {
            e.printStackTrace();
        } catch (BarcodeException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.调用工具类测试一下

  @org.junit.Test
    public void test1() throws IOException {
        BarCodeUtils.generateBarCode128("V000001", true, false,"./bbb.jpg");
    }

4.生成条形码图片

二维码

生成带logo的二维码

import java.util.Objects;

import javax.imageio.ImageIO;
import org.apache.commons.lang3.StringUtils;
import com.google.zxing.BarcodeFormat;
import com.google.zxing.EncodeHintType;
import com.google.zxing.MultiFormatWriter;
import com.google.zxing.WriterException;
import com.google.zxing.common.BitMatrix;
import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;

/**
 * 画制定logo和制定描述的二维码
 依赖
 <dependency>
 <groupId>com.google.zxing</groupId>
 <artifactId>core</artifactId>
 <version>3.2.1</version>
 </dependency>
<dependency>
 <groupId>com.google.zxing</groupId>
 <artifactId>javase</artifactId>
 <version>3.2.1</version>
 </dependency>
 */

public class QrCodeUtil {
    private static final int QRCOLOR = 0xFF000000; // 默认是黑色
    private static final int BGWHITE = 0xFFFFFFFF; // 背景颜色

    private static final int WIDTH = 400; // 二维码宽
    private static final int HEIGHT = 400; // 二维码高

    // 用于设置QR二维码参数
   private static Map<EncodeHintType, Object> hints = new HashMap<EncodeHintType, Object>() {
        private static final long serialVersionUID = 1L;

        {
            put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.H);// 设置QR二维码的纠错级别（H为最高级别）具体级别信息
            put(EncodeHintType.CHARACTER_SET, "utf-8");// 设置编码方式
            put(EncodeHintType.MARGIN, 0);
        }
    };


    public static void main(String[] args) throws WriterException {
        File logoFile = new File("D://QrCode/logo3.png");
        File QrCodeFile = new File("D://QrCode/05.png");
        String url = "http://ganyintao.top/";
        String note = "在下老甘";
        drawLogoQRCode(logoFile, QrCodeFile, url, note);
    }

  // 生成带logo的二维码图片
    public static void drawLogoQRCode(File logoFile, File codeFile, String qrUrl, String note) {
        try {
            MultiFormatWriter multiFormatWriter = new MultiFormatWriter();
            // 参数顺序分别为：编码内容，编码类型，生成图片宽度，生成图片高度，设置参数
            BitMatrix bm = multiFormatWriter.encode(qrUrl, BarcodeFormat.QR_CODE, WIDTH, HEIGHT, hints);
            BufferedImage image = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);

            // 开始利用二维码数据创建Bitmap图片，分别设为黑（0xFFFFFFFF）白（0xFF000000）两色
            for (int x = 0; x < WIDTH; x++) {
                for (int y = 0; y < HEIGHT; y++) {
                    image.setRGB(x, y, bm.get(x, y) ? QRCOLOR : BGWHITE);
                }
            }

            int width = image.getWidth();
           int height = image.getHeight();
            if (Objects.nonNull(logoFile) && logoFile.exists()) {
                // 构建绘图对象
                Graphics2D g = image.createGraphics();
                // 读取Logo图片
                BufferedImage logo = ImageIO.read(logoFile);
                // 开始绘制logo图片
                g.drawImage(logo, width * 2 / 5, height * 2 / 5, width * 2 / 10, height * 2 / 10, null);
                g.dispose();
                logo.flush();
            }

            // 自定义文本描述
            if (StringUtils.isNotEmpty(note)) {
                // 新的图片，把带logo的二维码下面加上文字
                BufferedImage outImage = new BufferedImage(400, 445, BufferedImage.TYPE_4BYTE_ABGR);
                Graphics2D outg = outImage.createGraphics();
                // 画二维码到新的面板
                outg.drawImage(image, 0, 0, image.getWidth(), image.getHeight(), null);
                // 画文字到新的面板
                outg.setColor(Color.BLACK);
                outg.setFont(new Font("楷体", Font.BOLD, 30)); // 字体、字型、字号
                int strWidth = outg.getFontMetrics().stringWidth(note);
                if (strWidth > 399) {
                    // //长度过长就截取前面部分
                    // 长度过长就换行
                    String note1 = note.substring(0, note.length() / 2);
                    String note2 = note.substring(note.length() / 2, note.length());
                    int strWidth1 = outg.getFontMetrics().stringWidth(note1);
                    int strWidth2 = outg.getFontMetrics().stringWidth(note2);
                    outg.drawString(note1, 200 - strWidth1 / 2, height + (outImage.getHeight() - height) / 2 + 12);
                    BufferedImage outImage2 = new BufferedImage(400, 485, BufferedImage.TYPE_4BYTE_ABGR);
                    Graphics2D outg2 = outImage2.createGraphics();
                    outg2.drawImage(outImage, 0, 0, outImage.getWidth(), outImage.getHeight(), null);
                    outg2.setColor(Color.BLACK);
                   outg2.setFont(new Font("宋体", Font.BOLD, 30)); // 字体、字型、字号
                    outg2.drawString(note2, 200 - strWidth2 / 2, outImage.getHeight() + (outImage2.getHeight() - outImage.getHeight()) / 2 + 5);
                    outg2.dispose();
                   outImage2.flush();
                    outImage = outImage2;
                } else {
                    outg.drawString(note, 200 - strWidth / 2, height + (outImage.getHeight() - height) / 2 + 12); // 画文字
                }
                outg.dispose();
                outImage.flush();
                image = outImage;
            }

            image.flush();
            ImageIO.write(image, "png", codeFile); // TODO
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

二、验证码

1.工具

public class ImageVerificationCode {

    private int weight = 100;           //验证码图片的长和宽
    private int height = 40;
    private String text;                //用来保存验证码的文本内容
    private Random r = new Random();    //获取随机数对象
    //private String[] fontNames = {"宋体", "华文楷体", "黑体", "微软雅黑", "楷体_GB2312"};   //字体数组
    //字体数组
    private String[] fontNames = {"Georgia"};
    //验证码数组
    private String codes = "23456789abcdefghjkmnopqrstuvwxyzABCDEFGHJKMNPQRSTUVWXYZ";

    /**
     * 获取随机的颜色
     *
     * @return
     */
    private Color randomColor() {
        int r = this.r.nextInt(225);  //这里为什么是225，因为当r，g，b都为255时，即为白色，为了好辨认，需要颜色深一点。
        int g = this.r.nextInt(225);
        int b = this.r.nextInt(225);
        return new Color(r, g, b);            //返回一个随机颜色
    }

    /**
     * 获取随机字体
     *
     * @return
     */
    private Font randomFont() {
        int index = r.nextInt(fontNames.length);  //获取随机的字体
        String fontName = fontNames[index];
        int style = r.nextInt(4);         //随机获取字体的样式，0是无样式，1是加粗，2是斜体，3是加粗加斜体
        int size = r.nextInt(10) + 24;    //随机获取字体的大小
        return new Font(fontName, style, size);   //返回一个随机的字体
    }

    /**
     * 获取随机字符
     *
     * @return
     */
    private char randomChar() {
        int index = r.nextInt(codes.length());
        return codes.charAt(index);
    }

    /**
     * 画干扰线，验证码干扰线用来防止计算机解析图片
     *
     * @param image
     */
    private void drawLine(BufferedImage image) {
        int num = r.nextInt(10); //定义干扰线的数量
        Graphics2D g = (Graphics2D) image.getGraphics();
        for (int i = 0; i < num; i++) {
            int x1 = r.nextInt(weight);
            int y1 = r.nextInt(height);
            int x2 = r.nextInt(weight);
            int y2 = r.nextInt(height);
            g.setColor(randomColor());
            g.drawLine(x1, y1, x2, y2);
        }
    }

    /**
     * 创建图片的方法
     *
     * @return
     */
    private BufferedImage createImage() {
        //创建图片缓冲区
        BufferedImage image = new BufferedImage(weight, height, BufferedImage.TYPE_INT_RGB);
        //获取画笔
        Graphics2D g = (Graphics2D) image.getGraphics();
        //设置背景色随机
        g.setColor(Color.white);
        g.fillRect(0, 0, weight, height);
        //返回一个图片
        return image;
    }

    /**
     * 获取验证码图片的方法
     *
     * @return
     */
    public BufferedImage getImage() {
        BufferedImage image = createImage();
        Graphics2D g = (Graphics2D) image.getGraphics(); //获取画笔
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 4; i++)             //画四个字符即可
        {
            String s = randomChar() + "";      //随机生成字符，因为只有画字符串的方法，没有画字符的方法，所以需要将字符变成字符串再画
            sb.append(s);                      //添加到StringBuilder里面
            float x = i * 1.0F * weight / 4;   //定义字符的x坐标
            g.setFont(randomFont());           //设置字体，随机
            g.setColor(randomColor());         //设置颜色，随机
            g.drawString(s, x, height - 5);
        }
        this.text = sb.toString();
        drawLine(image);
        return image;
    }

    /**
     * 获取验证码文本的方法
     *
     * @return
     */
    public String getText() {
        return text;
    }

    public static void output(BufferedImage image, OutputStream out) throws IOException                  //将验证码图片写出的方法
    {
        ImageIO.write(image, "JPEG", out);
    }
}

2、controller接口

    @GetMapping("/getCode")
    public ResResult<Map<String,String>> getCode(HttpServletRequest request) throws IOException {
        /*
             1.生成验证码
             2.把验证码上的文本存在session中
             3.把验证码图片发送给客户端
             */
        ImageVerificationCode ivc = new ImageVerificationCode();     //用我们的验证码类，生成验证码类对象
        BufferedImage image = ivc.getImage();  //获取验证码
        request.getSession().setAttribute("text", ivc.getText());
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        ImageIO.write(image, "png", stream);
        String base64 = Base64.encode(stream.toByteArray());//将验证码的文本存在session中
        Map<String,String> map = new HashMap<>();
        map.put("sessionId",request.getSession().getId());
        map.put("text",base64);
        redisUtils.set(request.getSession().getId(),ivc.getText(),60);
        return new ResResult<>(map);//将验证码图片响应给客户端
    }

三、压缩图片和加水印（2023.7.14补充）

1.引入依赖

        <dependency>
            <groupId>net.coobird</groupId>
            <artifactId>thumbnailator</artifactId>
            <version>0.4.8</version>
        </dependency>

2.工具类

import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.*;
import java.util.List;

import com.arcvideo.sgms.common.util.poi.StringUtils;
import com.google.common.collect.Lists;
import lombok.extern.slf4j.Slf4j;
import net.coobird.thumbnailator.Thumbnails;
import net.coobird.thumbnailator.geometry.Positions;


/**
 * 图片处理工具类
 *
 * @author ygan
 */
@Slf4j
public class ImageUtils{

    /**
     *
     * @param sourceFile  需要压缩的原图
     * @param targetFile   压缩后输出的图片
     * @param scale        压缩后图片宽高大小对比原图的比例 值在0-1之间，1f就是原图，0.5就是原图的一半大小
     * @param outputQuality  图片压缩的质量 值在0-1 之间，越接近1质量越好，越接近0质量越差
     * @param outputFormat  输出的文件后缀格式
     * @param watermark  水印文字
     * @param watermarkOpacity  水印透明度
     */
    public static void photoCompression(File sourceFile, File targetFile, double scale, double outputQuality,
                                        String outputFormat,String watermark,float watermarkOpacity) {


        try {
            outputFormat = outputFormat.replace(".","");
            List<String> suffixs = Lists.newArrayList("jpg", "jpeg", "png", "gif","log"); //只支持压缩这些格式的图片
            if(!suffixs.contains(outputFormat)){
                targetFile = sourceFile; 
                return;
            }


            Thumbnails.of(sourceFile)
                    .watermark(Positions.BOTTOM_RIGHT, handleTextWaterMark(watermark),watermarkOpacity )
                    .scale(scale)
                    .outputQuality(outputQuality)
                    .outputFormat(outputFormat)
                    .toFile(targetFile);
        } catch (IOException e) {
            targetFile = sourceFile; //压缩失败，直接不压缩了
            e.printStackTrace();
            log.info("图片压缩失败，路径: {}",sourceFile.getPath());
        }


    }

    /**
     * @return java.awt.image.BufferedImage
     * @throws
     * @description 操纵文字型水印
     * @params [address, dealerName, latitudeCommaLongitude, date]
     */
    private static BufferedImage handleTextWaterMark(String content) {

        Font font = new Font("Arial", Font.BOLD, 50);

        // 创建一个800x320像素的BufferedImage图像，使用RGB颜色模式
        BufferedImage image = new BufferedImage(800, 360, BufferedImage.TYPE_INT_RGB);
        Graphics2D g = image.createGraphics();
        //width 右间距，越小越靠近右边，  height: 下间距，越小越靠近下面
        image = g.getDeviceConfiguration().createCompatibleImage(20+content.length()*50, 100, Transparency.TRANSLUCENT);

        int y = 0;
        int divider30 = 60; //图片的高度

        g = image.createGraphics();
        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g.setColor(Color.red);
        g.setFont(font);

        if (StringUtils.isNotBlank(content)) {
            g.drawString(content, 5, y += divider30);
        }

        g.dispose();
        return image;
    }


    public static void main(String[] args) {
        File file = new File("test.jpeg");
        File file1 = new File("test1.jpeg");

        photoCompression(file,file1,1,0.3,"jpeg","水印文字测试",0.5f);

    }


}

3、效果

原图

 压缩后