Tratamento de Imagem

import java.io.IOException;
import java.util.Base64;

  public byte[] decodeB64(String b64img) throws ImageDecodingException {
      if (b64img == null || b64img.trim().isEmpty()) {
          throw new ImageDecodingException("Base64 string is null or empty in payload");
      }

      try {
          return Base64.getDecoder().decode(b64img);
      } catch (IllegalArgumentException e) {
          throw new ImageDecodingException("Error decoding Base64 string", e);
      }
  }

public String encodeB64(byte[] imgArray) {
    return Base64.getEncoder().encodeToString(imgArray);
}

class ImageDecodingException extends IOException {
    public ImageDecodingException(String message) {
        super(message);
    }

    public ImageDecodingException(String message, Throwable cause) {
        super(message, cause);
    }
}

import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.stream.ImageOutputStream;
import java.awt.image.BufferedImage;
import java.awt.image.ColorConvertOp;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Iterator;

private static synchronized byte[] encodeToJPEG(byte[] data, float qualityLevel)
throws ImageEncodingException, IllegalArgumentException {
    if (data == null || data.length == 0) {
        throw new IllegalArgumentException("O array de bytes da imagem não pode ser nulo ou vazio.");
    }

    if (qualityLevel < 0.0 || qualityLevel > 1.0) {
        throw new IllegalArgumentException("O nível de qualidade deve estar entre 0.0 e 1.0.");
    }

    try {
        BufferedImage rawImage = ImageIO.read(new ByteArrayInputStream(data));
        BufferedImage image = new BufferedImage(rawImage.getWidth(), rawImage.getHeight(), BufferedImage.TYPE_INT_RGB);

        ColorConvertOp xformOp = new ColorConvertOp(null);
        xformOp.filter(rawImage, image);

        Iterator < ImageWriter > iter = ImageIO.getImageWritersByFormatName("jpeg");
        ImageWriter writer = iter.next();

        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        ImageOutputStream ios = ImageIO.createImageOutputStream(bytes);
        writer.setOutput(ios);

        ImageWriteParam param = writer.getDefaultWriteParam();
        param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
        param.setCompressionQuality(qualityLevel);
        if (qualityLevel == 1.0) {
            param.setSourceSubsampling(1, 1, 0, 0);
        }

        IIOImage iioImage = new IIOImage(image, null, null);
        writer.write(null, iioImage, param);
        ios.close();
        writer.dispose();

        return bytes.toByteArray();
    } catch (IOException e) {
        throw new ImageEncodingException("Erro durante a codificação da imagem.", e);
    }
}

class ImageEncodingException extends IOException {
    public ImageEncodingException(String message) {
        super(message);
    }

    public ImageEncodingException(String message, Throwable cause) {
        super(message, cause);
    }
}

import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

public BufferedImage resizeByScale(BufferedImage original, int scale) {
        if (original == null) {
            throw new IllegalArgumentException("A imagem original não pode ser nula.");
        }

        if (scale != 0) {
            int newWidth = original.getWidth() / scale;
            int newHeight = original.getHeight() / scale;
            return resizeBySize(original, newWidth, newHeight);
        } else {
            return original;
        }
    }

public BufferedImage resizeBySize(BufferedImage original, int newWidth, int newHeight) {
        return resizeBySize(original, newWidth, newHeight, BufferedImage.TYPE_INT_ARGB);
    }

public BufferedImage resizeBySize(BufferedImage original, int newWidth, int newHeight, int type) {
        if (original == null) {
            throw new IllegalArgumentException("A imagem original não pode ser nula.");
        }

        int oldWidth = original.getWidth();
        int oldHeight = original.getHeight();
        BufferedImage resized = new BufferedImage(newWidth, newHeight, type);

        try (Graphics2D graphics2D = resized.createGraphics()) {
            graphics2D.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);

            graphics2D.drawImage(original,
                    0, 0, newWidth, newHeight,
                    0, 0, oldWidth, oldHeight,
                    null);
        }

        return resized;
    }

public byte[] resizeBytesBySize(byte[] original, int newWidth, int newHeight) {
    if (original == null) {
        throw new IllegalArgumentException("O array de bytes da imagem original não pode ser nulo.");
    }

    try {
        BufferedImage input = ImageIO.read(new ByteArrayInputStream(original));
        BufferedImage resized = resizeBySize(input, newWidth, newHeight, BufferedImage.TYPE_INT_RGB);

        try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
            ImageIO.write(resized, "jpg", byteArrayOutputStream);
            return byteArrayOutputStream.toByteArray();
        }
    } catch (IOException e) {
        log.warn("IOException durante o redimensionamento - {}", e.toString());
        return original;
    }
}