图片转换及水印

package io.github.syske;

import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;

import javax.imageio.ImageIO;
import javax.swing.JLabel;

/**
 * @program: imagUtils
 * @description: 图片水印工具
 * @create: 2020-02-18 13:48
 */

public class WatermarkImgUtils {

    public static void main(String[] args) {
        System.out.println("开始水印：");
        new WatermarkImgUtils().addWatermark("D://20201124213253.jpg", "d:/20201124213253_after.jpg", "仅用于面试证明", "jpg", 1.4d);
        System.out.println("水印完成。");
    }

    /**
     * @param sourceImgPath    源图片路径
     * @param tarImgPath       保存的图片路径
     * @param waterMarkContent 水印内容
     * @param fileExt          图片格式
     * @return void
     * @description
     */
    public void addWatermark(String sourceImgPath, String tarImgPath, String waterMarkContent, String fileExt, double cos) {
        Font font = new Font("宋体", Font.BOLD, 25);//水印字体，大小
        Color markContentColor = Color.red;//水印颜色
        Integer degree = 45;//设置水印文字的旋转角度
        float alpha = 0.5f;//设置水印透明度
        OutputStream outImgStream = null;
        try {
            File srcImgFile = new File(sourceImgPath);//得到文件
            Image srcImg = ImageIO.read(srcImgFile);//文件转化为图片
            int srcImgWidth = srcImg.getWidth(null);//获取图片的宽
            int srcImgHeight = srcImg.getHeight(null);//获取图片的高
            // 加水印
            BufferedImage bufImg = new BufferedImage(srcImgWidth, srcImgHeight, BufferedImage.TYPE_INT_RGB);
            Graphics2D g = bufImg.createGraphics();//得到画笔
            g.drawImage(srcImg, 0, 0, srcImgWidth, srcImgHeight, null);
            g.setColor(markContentColor); //设置水印颜色
            g.setFont(font);              //设置字体
            g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, alpha));//设置水印文字透明度
            if (null != degree) {
                g.rotate(Math.toRadians(degree));//设置水印旋转
            }
            JLabel label = new JLabel(waterMarkContent);
            FontMetrics metrics = label.getFontMetrics(font);
            int width = (int) Math.ceil(metrics.stringWidth(label.getText()) / cos);//文字水印的宽
            int rowsNumber = srcImgHeight / width;// 图片的高  除以  文字水印的宽    ——> 打印的行数(以文字水印的宽为间隔)
            int columnsNumber = srcImgWidth / width;//图片的宽 除以 文字水印的宽   ——> 每行打印的列数(以文字水印的宽为间隔)
            //防止图片太小而文字水印太长，所以至少打印一次
            if (rowsNumber < 1) {
                rowsNumber = 1;
            }
            if (columnsNumber < 1) {
                columnsNumber = 1;
            }
            for (int j = 0; j < rowsNumber; j++) {
                for (int i = 0; i < columnsNumber; i++) {
                    g.drawString(waterMarkContent, i * width + j * width, -i * width + j * width);//画出水印,并设置水印位置
                }
            }
            g.dispose();// 释放资源
            // 输出图片
            outImgStream = new FileOutputStream(tarImgPath);
            ImageIO.write(bufImg, fileExt, outImgStream);
        } catch (Exception e) {
            e.printStackTrace();
            e.getMessage();
        } finally {
            try {
                if (outImgStream != null) {
                    outImgStream.flush();
                    outImgStream.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
                e.getMessage();
            }
        }
    }
}

/**
 * @program: imagUtils
 * @description: 图片转base64
 * @create: 2020-02-18 13:51
 */

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.UUID;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

public class Base64Util {
    private transient static Logger log = LoggerFactory.getLogger(Base64Util.class);

    /**
     * base64字符串转byte
     *
     * @param imageBase64Str
     * @return
     */
    public static byte[] base64topng(String imageBase64Str) {
        byte[] b1 = null;
        BASE64Decoder decoder = new BASE64Decoder();
        try {
            if (imageBase64Str.indexOf("data:image/jpeg;base64,") != -1) {
                b1 = decoder.decodeBuffer(imageBase64Str.replaceAll("data:image/jpeg;base64,", ""));
            } else if (imageBase64Str.indexOf("data:image/png;base64,") != -1) {
                b1 = decoder.decodeBuffer(imageBase64Str.replaceAll(
                        "data:image/png;base64,", ""));
            } else if (imageBase64Str.indexOf("data:image/jpg;base64,") != -1) {
                b1 = decoder.decodeBuffer(imageBase64Str.replaceAll(
                        "data:image/jpg;base64,", ""));
            } else {
                b1 = decoder.decodeBuffer(imageBase64Str);
            }
            for (int i = 0; i < b1.length; ++i) {
                if (b1[i] < 0) {// 调整异常数据
                    b1[i] += 256;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return b1;
    }

    /**
     * 保存图片
     *
     * @param realPath
     * @param imageStr base64字符串
     * @return imgName
     */
    public static String filePath(String realPath, String imageStr) {
        String imgPath = "";
        String imgName = "";
        try {
            byte[] imageBytes = base64topng(imageStr);
            File f1 = new File(realPath);
            if (!f1.exists()) {
                f1.mkdir();
            }
            imgName = UUID.randomUUID().toString() + ".jpg";
            imgPath = realPath + "/" + imgName;
            File f2 = new File(imgPath);
            if (!f2.exists()) {
                f2.createNewFile();
            }
            OutputStream out = new FileOutputStream(imgPath);
            out.write(imageBytes);
            out.flush();
            out.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
        return imgName;
    }


    /**
     * base64字符串转化成图片
     *
     * @param imgData 图片编码
     * @return
     * @throws IOException
     */
    public static String GenerateImage(String filePath, String imgData) throws IOException { // 对字节数组字符串进行Base64解码并生成图片
        String imgName = UUID.randomUUID().toString() + ".jpg";
        if (imgData == null) // 图像数据为空
            return null;
        BASE64Decoder decoder = new BASE64Decoder();
        OutputStream out = null;
        try {
            out = new FileOutputStream(filePath + imgName);
            // Base64解码
            byte[] b = decoder.decodeBuffer(imgData);
            for (int i = 0; i < b.length; ++i) {
                if (b[i] < 0) {// 调整异常数据
                    b[i] += 256;
                }
            }
            out.write(b);
        } catch (IOException e) {
            log.error("图片转换失败：" + e);
            e.printStackTrace();
        } finally {
            out.flush();
            out.close();
        }
        return imgName;
    }


    /**
     * 图片转化成base64字符串
     *
     * @param imgPath
     * @return
     */
    public static String GetImageStr(String imgPath) {// 将图片文件转化为字节数组字符串，并对其进行Base64编码处理
        String imgFile = imgPath;// 待处理的图片
        InputStream in = null;
        byte[] data = null;
        String encode = null; // 返回Base64编码过的字节数组字符串
        // 对字节数组Base64编码
        BASE64Encoder encoder = new BASE64Encoder();
        try {
            // 读取图片字节数组
            in = new FileInputStream(imgFile);
            data = new byte[in.available()];
            in.read(data);
            encode = encoder.encode(data);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                in.close();
            } catch (IOException e) {
                log.error("图片转换失败：" + e);
                e.printStackTrace();
            }
        }
        return encode;
    }

}