Java

一、介绍

在实际的系统开发中，某些业务场景下，经常需要给原始图片添加水印，以防止图片信息在互联网上随意传播！
也有的基于当下的业务需求，需要给相机照片加水印、地理位置、时间等信息，以方便记录自己的生活！
有的人可能很容易想到，通过 PS 技术就可以很轻松的完成！
的确，对于单个图像而言很容易，但是对于成千上万的图像，采用人工处理，显然不可取！
问题来了，面对大批量的图像加水印需求，应当如何处理呢？
试想一下，如果采用人工方式来给图像添加水印，大概的步骤离不开以下几步：
1、先获取需要处理的图像
2、然后将图像摆放整齐，用尺子计算出需要加水印的位置
3、采用画笔准确无误的在对应的位置上画上水印
4、最后，水印添加之后！
如果采用程序来实现，思路也是一样的，废话也不多说了，代码直接撸上！

二、程序实践

下面以java程序为例，给以下图添加一段复印无效的文字水印，并居中！
Java给图像加水印 - 图1
程序实践如下：

  1. import org.apache.commons.lang3.StringUtils;
  2. import javax.imageio.ImageIO;
  3. import java.awt.*;
  4. import java.awt.image.BufferedImage;
  5. import java.io.File;
  7. /**
  8.  * 给图像添加水印
  9.  * @since 2021-10-29
  10.  */
  11. public class ImageWaterMarkUtil {
  15.     /**
  16.      * 给图像添加文字水印
  17.      * @param srcImgPath     原始文件地址
  18.      * @param targetImgPath  目标文件地址
  19.      * @param text           水印内容
  20.      * @param color          水印文字颜色
  21.      * @param font           水印文字字体
  22.      * @param alpha          水印透明度
  23.      * @param positionWidth  水印横向位置
  24.      * @param positionHeight 水印纵向位置
  25.      * @param degree         水印图片旋转角度
  26.      * @param location       水印的位置，左上角、右上角、左下角、右下角、居中
  27.      */
  28.     public static void markImage(String srcImgPath,
  29.                                  String targetImgPath,
  30.                                  String text,
  31.                                  Color color,
  32.                                  Font font,
  33.                                  float alpha,
  34.                                  int positionWidth,
  35.                                  int positionHeight,
  36.                                  Integer degree,
  37.                                  String location) {
  38.         try {
  39.             // 1、读取源图片
  40.             Image srcImg = ImageIO.read(new File(srcImgPath));
  41.             int srcImgWidth = srcImg.getWidth(null);
  42.             int srcImgHeight = srcImg.getHeight(null);
  43.             BufferedImage buffImg = new BufferedImage(srcImgWidth, srcImgHeight, BufferedImage.TYPE_INT_RGB);
  45.             // 2、得到画笔对象
  46.             Graphics2D g = buffImg.createGraphics();
  47.             // 3、设置对线段的锯齿状边缘处理
  48.             g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
  49.             g.drawImage(srcImg.getScaledInstance(srcImgWidth, srcImgHeight, Image.SCALE_SMOOTH), 0, 0, null);
  50.             // 4、设置水印旋转
  51.             if (null != degree) {
  52.                 g.rotate(Math.toRadians(degree), (double) buffImg.getWidth() / 2, (double) buffImg.getHeight() / 2);
  53.             }
  54.             // 5、设置水印文字颜色
  55.             g.setColor(color);
  56.             // 6、设置水印文字Font
  57.             g.setFont(font);
  58.             // 7、设置水印文字透明度
  59.             g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, alpha));
  60.             // 8、水印图片的位置
  61.             int x = 0, y = 0;
  62.             if (StringUtils.equals(location, "left-top")) {
  63.                 x = 30;
  64.                 y = font.getSize();
  65.             } else if (StringUtils.equals(location, "right-top")) {
  66.                 x = srcImgWidth - getWatermarkLength(text, g) - 30;
  67.                 y = font.getSize();
  68.             } else if (StringUtils.equals(location, "left-bottom")) {
  69.                 x += 30;
  70.                 y = buffImg.getHeight() - font.getSize();
  71.             } else if (StringUtils.equals(location, "right-bottom")) {
  72.                 x = srcImgWidth - getWatermarkLength(text, g) - 30;
  73.                 y = srcImgHeight - font.getSize();
  74.             } else if (StringUtils.equals(location, "center")) {
  75.                 x = (srcImgWidth - getWatermarkLength(text, g)) / 2;
  76.                 y = srcImgHeight / 2;
  77.             } else {
  78.                 //自定义位置
  79.                 x = positionWidth;
  80.                 y = positionHeight;
  81.             }
  82.             // 9、第一参数->设置的内容，后面两个参数->文字在图片上的坐标位置(x,y)
  83.             g.drawString(text, x, y);
  84.             // 10、释放资源
  85.             g.dispose();
  86.             // 11、生成图片
  87.             ImageIO.write(buffImg, "png", new File(targetImgPath));
  88.             System.out.println("图片完成添加水印文字");
  89.         } catch (Exception e) {
  90.             e.printStackTrace();
  91.         }
  92.     }
  94.     /**
  95.      * 计算填充的水印长度
  96.      * @param text
  97.      * @param g
  98.      * @return
  99.      */
  100.     private static int getWatermarkLength(String text, Graphics2D g) {
  101.         return g.getFontMetrics(g.getFont()).charsWidth(text.toCharArray(), 0, text.length());
  102.     }
  104.     public static void main(String[] args) {
  105.         String srcImgPath = "/Users/pzblog/Desktop/Jietu.jpg"; //原始文件地址
  106.         String targetImgPath = "/Users/pzblog/Desktop/Jietu-copy.jpg"; //目标文件地址
  107.         String text = "复 印 无 效"; //水印文字内容
  108.         Color color = Color.red; //水印文字颜色
  109.         Font font = new Font("宋体", Font.BOLD, 60); //水印文字字体
  110.         float alpha = 0.4f; //水印透明度
  111.         int positionWidth = 320; //水印横向位置坐标
  112.         int positionHeight = 450; //水印纵向位置坐标
  113.         Integer degree = -30; //水印旋转角度
  114.         String location = "center"; //水印的位置
  115.         //给图片添加文字水印
  116.         markImage(srcImgPath, targetImgPath, text, color, font, alpha, positionWidth, positionHeight, degree, location);
  117.     }
  118. }

运行结果如下：
Java给图像加水印 - 图2
水印添加成功！

2.1、给图像添加多处文字

有的需求会要求给图像添加多处文字水印，例如下图！
Java给图像加水印 - 图3
处理过程也很简单！

  1. import javax.imageio.ImageIO;
  2. import java.awt.*;
  3. import java.awt.image.BufferedImage;
  4. import java.io.File;
  6. /**
  7.  * 给图像添加水印
  8.  * @since 2021-10-29
  9.  */
  10. public class ImageFullWaterMarkUtil {
  14.     /**
  15.      * 给图像添加多处文字水印
  16.      * @param srcImgPath     原始文件地址
  17.      * @param targetImgPath  目标文件地址
  18.      * @param text           水印内容
  19.      * @param color          水印文字颜色
  20.      * @param font           水印文字字体
  21.      * @param alpha          水印透明度
  22.      * @param startWidth     水印横向起始位置
  23.      * @param degree         水印图片旋转角度
  24.      * @param interval       高度间隔
  25.      */
  26.     public static void fullMarkImage(String srcImgPath,
  27.                                  String targetImgPath,
  28.                                  String text,
  29.                                  Color color,
  30.                                  Font font,
  31.                                  float alpha,
  32.                                  int startWidth,
  33.                                  Integer degree,
  34.                                  Integer interval) {
  35.         try {
  36.             // 1、读取源图片
  37.             Image srcImg = ImageIO.read(new File(srcImgPath));
  38.             int srcImgWidth = srcImg.getWidth(null);
  39.             int srcImgHeight = srcImg.getHeight(null);
  40.             BufferedImage buffImg = new BufferedImage(srcImgWidth, srcImgHeight, BufferedImage.TYPE_INT_RGB);
  42.             // 2、得到画笔对象
  43.             Graphics2D g = buffImg.createGraphics();
  44.             // 3、设置对线段的锯齿状边缘处理
  45.             g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
  46.             g.drawImage(srcImg.getScaledInstance(srcImgWidth, srcImgHeight, Image.SCALE_SMOOTH), 0, 0, null);
  47.             // 4、设置水印旋转
  48.             if (null != degree) {
  49.                 g.rotate(Math.toRadians(degree), (double) buffImg.getWidth() / 2, (double) buffImg.getHeight() / 2);
  50.             }
  51.             // 5、设置水印文字颜色
  52.             g.setColor(color);
  53.             // 6、设置水印文字Font
  54.             g.setFont(font);
  55.             // 7、设置水印文字透明度
  56.             g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, alpha));
  57.             // 8、水印图片的位置
  58.             int x = startWidth;
  59.             int y = font.getSize();
  60.             int space = srcImgHeight / interval;
  61.             for (int i = 0; i < space; i++) {
  62.                 //如果最后一个坐标的y轴比height高，直接退出
  63.                 if (((y + font.getSize()) > srcImgHeight) || ((x + getWatermarkLength(text,g))  > srcImgWidth)) {
  64.                     break;
  65.                 }
  66.                 //9、进行绘制
  67.                 g.drawString(text, x, y);
  68.                 x += getWatermarkLength(text,g);
  69.                 y += font.getSize() + interval;
  70.             }
  71.             // 10、释放资源
  72.             g.dispose();
  73.             // 11、生成图片
  74.             ImageIO.write(buffImg, "png", new File(targetImgPath));
  75.             System.out.println("图片完成添加水印文字");
  76.         } catch (Exception e) {
  77.             e.printStackTrace();
  78.         }
  79.     }
  81.     /**
  82.      * 计算填充的水印长度
  83.      * @param text
  84.      * @param g
  85.      * @return
  86.      */
  87.     private static int getWatermarkLength(String text, Graphics2D g) {
  88.         return g.getFontMetrics(g.getFont()).charsWidth(text.toCharArray(), 0, text.length());
  89.     }
  91.     public static void main(String[] args) {
  92.         String srcImgPath = "/Users/pzblog/Desktop/Jietu.jpg"; //原始文件地址
  93.         String targetImgPath = "/Users/pzblog/Desktop/Jietu-copy-full.jpg"; //目标文件地址
  94.         String text = "复 印 无 效"; //水印文字内容
  95.         Color color = Color.red; //水印文字颜色
  96.         Font font = new Font("宋体", Font.BOLD, 30); //水印文字字体
  97.         float alpha = 0.4f; //水印透明度
  98.         int startWidth = 30; //水印横向位置坐标
  99.         Integer degree = -0; //水印旋转角度
  100.         Integer interval = 100; //水印的位置
  101.         //给图片添加文字水印
  102.         fullMarkImage(srcImgPath, targetImgPath, text, color, font, alpha, startWidth, degree, interval);
  103.     }
  104. }

2.2、给图像添加图片水印

某些情况下，还需要给图像添加图片水印，例如下图效果！
Java给图像加水印 - 图4
处理过程也很简单！

  1. import org.apache.commons.lang3.StringUtils;
  3. import javax.imageio.ImageIO;
  4. import javax.swing.*;
  5. import java.awt.*;
  6. import java.awt.image.BufferedImage;
  7. import java.io.File;
  9. /**
  10.  * 给图像添加水印
  11.  * @since 2021-10-29
  12.  */
  13. public class ImageIconWaterMarkUtil {
  17.     /**
  18.      * 给图像添加多处文字水印
  19.      * @param srcImgPath     原始文件地址
  20.      * @param targetImgPath  目标文件地址
  21.      * @param iconImgPath    水印icon
  22.      * @param alpha          水印透明度
  23.      * @param positionWidth  水印横向位置
  24.      * @param positionHeight 水印纵向位置
  25.      * @param degree         水印图片旋转角度
  26.      * @param location       水印的位置，左上角、右上角、左下角、右下角、居中
  27.      */
  28.     public static void fullMarkImage(String srcImgPath,
  29.                                  String targetImgPath,
  30.                                  String iconImgPath,
  31.                                  float alpha,
  32.                                  int positionWidth,
  33.                                  int positionHeight,
  34.                                  Integer degree,
  35.                                  String location) {
  36.         try {
  37.             // 1、读取源图片
  38.             Image srcImg = ImageIO.read(new File(srcImgPath));
  39.             int srcImgWidth = srcImg.getWidth(null);
  40.             int srcImgHeight = srcImg.getHeight(null);
  41.             BufferedImage buffImg = new BufferedImage(srcImgWidth, srcImgHeight, BufferedImage.TYPE_INT_RGB);
  43.             // 2、得到画笔对象
  44.             Graphics2D g = buffImg.createGraphics();
  45.             // 3、设置对线段的锯齿状边缘处理
  46.             g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
  47.             g.drawImage(srcImg.getScaledInstance(srcImgWidth, srcImgHeight, Image.SCALE_SMOOTH), 0, 0, null);
  48.             // 4、设置水印旋转
  49.             if (null != degree) {
  50.                 g.rotate(Math.toRadians(degree), (double) buffImg.getWidth() / 2, (double) buffImg.getHeight() / 2);
  51.             }
  52.             // 5、设置水印文字透明度
  53.             g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, alpha));
  55.             // 6、水印图片的路径 水印图片一般为gif或者png的，这样可设置透明度
  56.             ImageIcon imgIcon = new ImageIcon(iconImgPath);
  57.             // 7、得到Image对象。
  58.             Image iconImg = imgIcon.getImage();
  59.             int iconImgWidth = iconImg.getWidth(null);
  60.             int iconImgHeight = iconImg.getHeight(null);
  62.             int x = 0, y = 0;
  63.             if (StringUtils.equals(location, "left-top")) {
  64.                 x = iconImgWidth;
  65.                 y = iconImgHeight;
  66.             } else if (StringUtils.equals(location, "right-top")) {
  67.                 x = srcImgWidth - iconImgWidth - 30;
  68.                 y = iconImgHeight;
  69.             } else if (StringUtils.equals(location, "left-bottom")) {
  70.                 x += iconImgWidth;
  71.                 y = buffImg.getHeight() - iconImgHeight;
  72.             } else if (StringUtils.equals(location, "right-bottom")) {
  73.                 x = srcImgWidth - iconImgWidth - 30;
  74.                 y = srcImgHeight - iconImgHeight;
  75.             } else if (StringUtils.equals(location, "center")) {
  76.                 x = (srcImgWidth - iconImgWidth) / 2;
  77.                 y = (srcImgHeight - iconImgHeight) / 2;
  78.             } else {
  79.                 //自定义位置
  80.                 x = positionWidth;
  81.                 y = positionHeight;
  82.             }
  83.             g.drawImage(iconImg, x, y, null);
  84.             g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
  85.             // 10、释放资源
  86.             g.dispose();
  87.             // 11、生成图片
  88.             ImageIO.write(buffImg, "jpg", new File(targetImgPath));
  89.             System.out.println("图片完成添加图片水印文字");
  90.         } catch (Exception e) {
  91.             e.printStackTrace();
  92.         }
  93.     }
  95.     /**
  96.      * 计算填充的水印长度
  97.      * @param text
  98.      * @param g
  99.      * @return
  100.      */
  101.     private static int getWatermarkLength(String text, Graphics2D g) {
  102.         return g.getFontMetrics(g.getFont()).charsWidth(text.toCharArray(), 0, text.length());
  103.     }
  105.     public static void main(String[] args) {
  106.         String srcImgPath = "/Users/pzblog/Desktop/Jietu.jpg"; //原始文件地址
  107.         String targetImgPath = "/Users/pzblog/Desktop/Jietu-copy-img.jpg"; //目标文件地址
  108.         String iconImgPath = "/Users/pzblog/Desktop/1.png"; //图片水印地址
  109.         float alpha = 0.6f; //水印透明度
  110.         int positionWidth = 320; //水印横向位置坐标
  111.         int positionHeight = 450; //水印纵向位置坐标
  112.         Integer degree = 0; //水印旋转角度
  113.         String location = "center"; //水印的位置
  114.         //给图片添加文字水印
  115.         fullMarkImage(srcImgPath, targetImgPath, iconImgPath, alpha, positionWidth, positionHeight, degree, location);
  116.     }
  117. }

三、踩坑点

以上实现都很简单，但是在实际的实现过程中，却发现了一个巨大的坑，如果用的iphone手机拍摄的，按照以上代码进行添加水印，会发现图像突然变横了！
例如下图是原图：
Java给图像加水印 - 图5
按照上面添加水印的处理，得到的图像结果如下：
Java给图像加水印 - 图6
很明显，图像旋转了90度！
通过不同拍摄角度的反复测试，发现拍摄角度正常，但是经过程序处理之后，有些是需要旋转 90/180/270 度才能回正。
如果想要在正确的位置加上水印，就必须先对图像进行旋转回到原有的角度，然后再添加水印！
那问题来了，如何获取其旋转的角度呢？
经过查阅资料，对于图像的拍摄角度信息，有一个专业的名词：EXIF，EXIF是 Exchangeable Image File的缩写，这是一种专门为数码相机照片设定的格式。
这种格式可以用来记录数字照片的属性信息，例如相机的品牌及型号、相片的拍摄时间、拍摄时所设置的光圈大小、快门速度、ISO等等信息。除此之外它还能够记录拍摄数据，以及照片格式化方式。
通过它，可以得知图像的旋转角度信息！
下面一起来了解下采用 Java 语言如何读取图像的 EXIF 信息，包括如何根据 EXIF 信息对图像进行调整以适合用户浏览。

  • 首先添加 EXIF 依赖包

    1. <dependency>
    2.   <groupId>com.drewnoakes</groupId>
    3.   <artifactId>metadata-extractor</artifactId>
    4.   <version>2.16.0</version>
    5. </dependency>

  • 然后读取图像的 EXIF 信息 ```java import com.drew.imaging.ImageMetadataReader; import com.drew.imaging.ImageProcessingException; import com.drew.metadata.Directory; import com.drew.metadata.Metadata; import com.drew.metadata.Tag;

import java.io.File; import java.io.IOException;

public class EXIFTest {

  1. public static void main(String[] args) throws ImageProcessingException, IOException {
  2.     Metadata metadata = ImageMetadataReader.readMetadata(new File("/Users/pzblog/Desktop/11.jpeg"));
  4.     for (Directory directory : metadata.getDirectories()) {
  5.         for (Tag tag : directory.getTags()) {
  6.             System.out.println(String.format("[%s] - %s = %s",
  7.                     directory.getName(), tag.getTagName(), tag.getDescription()));
  8.         }
  9.         if (directory.hasErrors()) {
  10.             for (String error : directory.getErrors()) {
  11.                 System.err.format("ERROR: %s", error);
  12.             }
  13.         }
  14.     }
  15. }

}

  1. 输出结果：

[JPEG] - Compression Type = Baseline [JPEG] - Data Precision = 8 bits [JPEG] - Image Height = 1080 pixels [JPEG] - Image Width = 1440 pixels [JPEG] - Number of Components = 3 [JPEG] - Component 1 = Y component: Quantization table 0, Sampling factors 2 horiz/2 vert [JPEG] - Component 2 = Cb component: Quantization table 1, Sampling factors 1 horiz/1 vert [JPEG] - Component 3 = Cr component: Quantization table 1, Sampling factors 1 horiz/1 vert [JFIF] - Version = 1.1 [JFIF] - Resolution Units = none [JFIF] - X Resolution = 72 dots [JFIF] - Y Resolution = 72 dots [JFIF] - Thumbnail Width Pixels = 0 [JFIF] - Thumbnail Height Pixels = 0 [Exif IFD0] - Orientation = Right side, top (Rotate 90 CW) [Exif SubIFD] - Exif Image Width = 1440 pixels [Exif SubIFD] - Exif Image Height = 1080 pixels [ICC Profile] - Profile Size = 548 [ICC Profile] - CMM Type = appl [ICC Profile] - Version = 4.0.0 [ICC Profile] - Class = Display Device [ICC Profile] - Color space = RGB [ICC Profile] - Profile Connection Space = XYZ [ICC Profile] - Profile Date/Time = 2017:07:07 13:22:32 [ICC Profile] - Signature = acsp [ICC Profile] - Primary Platform = Apple Computer, Inc. [ICC Profile] - Device manufacturer = APPL [ICC Profile] - XYZ values = 0.964 1 0.825 [ICC Profile] - Tag Count = 10 [ICC Profile] - Profile Description = Display P3 [ICC Profile] - Profile Copyright = Copyright Apple Inc., 2017 [ICC Profile] - Media White Point = (0.9505, 1, 1.0891) [ICC Profile] - Red Colorant = (0.5151, 0.2412, 65536) [ICC Profile] - Green Colorant = (0.292, 0.6922, 0.0419) [ICC Profile] - Blue Colorant = (0.1571, 0.0666, 0.7841) [ICC Profile] - Red TRC = para (0x70617261): 32 bytes [ICC Profile] - Chromatic Adaptation = sf32 (0x73663332): 44 bytes [ICC Profile] - Blue TRC = para (0x70617261): 32 bytes [ICC Profile] - Green TRC = para (0x70617261): 32 bytes [Photoshop] - Caption Digest = 212 29 140 217 143 0 178 4 233 128 9 152 236 248 66 126 [Huffman] - Number of Tables = 4 Huffman tables [File Type] - Detected File Type Name = JPEG [File Type] - Detected File Type Long Name = Joint Photographic Experts Group [File Type] - Detected MIME Type = image/jpeg [File Type] - Expected File Name Extension = jpg [File] - File Name = 11.jpeg [File] - File Size = 234344 bytes [File] - File Modified Date = 星期日 十一月 07 20:05:52 +08:00 2021

  1. 其中`Orientation`标签描述的就是图像旋转的角度。

[Exif IFD0] - Orientation = Right side, top (Rotate 90 CW)

  1. 最后，可以通过`Orientation`信息计算出图像对应的旋转角度。
  2. ```java
  3. import com.alibaba.fastjson.JSON;
  4. import com.drew.imaging.jpeg.JpegMetadataReader;
  5. import com.drew.metadata.Directory;
  6. import com.drew.metadata.Metadata;
  7. import com.drew.metadata.Tag;
  9. import java.io.FileInputStream;
  10. import java.io.IOException;
  11. import java.io.InputStream;
  13. public class TransferImage {
  15.     public static void main(String[] args) throws IOException {
  16.         String path = "/Users/pzblog/Desktop/11.jpeg";
  17.         int result = getImgRotateAngle(new FileInputStream(path));
  18.         System.out.println(result);
  19.     }
  22.     public static int getImgRotateAngle(InputStream inputStream) {
  23.         int rotateAngle = 0;
  24.         try {
  25.             Metadata metadata = JpegMetadataReader.readMetadata(inputStream);
  26.             Iterable<Directory> directories = metadata.getDirectories();
  27.             for (Directory directory : directories) {
  28.                 for (Tag tag : directory.getTags()) {
  29.                     System.out.println(JSON.toJSONString(tag));
  31.                     int tagType = tag.getTagType();
  32.                     //照片拍摄角度信息
  33.                     if (274 == tagType) {
  34.                         String description = tag.getDescription();
  35.                         //Left side, bottom (Rotate 270 CW)
  36.                         switch (description) {
  37.                             //顺时针旋转90度
  38.                             case "Right side, top (Rotate 90 CW)":
  39.                                 rotateAngle = 90;
  40.                                 break;
  41.                             case "Left side, bottom (Rotate 270 CW)":
  42.                                 rotateAngle = 270;
  43.                                 break;
  44.                             case "Bottom, right side (Rotate 180)":
  45.                                 rotateAngle = 180;
  46.                                 break;
  47.                             default:
  48.                                 rotateAngle = 0;
  49.                                 break;
  50.                         }
  51.                     }
  53.                 }
  54.             }
  55.             return rotateAngle;
  56.         } catch (Exception e) {
  57.             return 0;
  58.         }
  59.     }
  60. }

输出的旋转角度结果：

  1. 90
  • 接着通过旋转角度参数，对图像进行回正 ```java import javax.imageio.ImageIO; import java.awt.*; import java.awt.image.BufferedImage; import java.io.File; import java.io.IOException;

public class RotateImage {

  1. public static BufferedImage rotate(Image src, int angel) {
  2.     int src_width = src.getWidth(null);
  3.     int src_height = src.getHeight(null);
  4.     // calculate the new image size
  5.     Rectangle rect_des = calcRotatedSize(new Rectangle(new Dimension(
  6.             src_width, src_height)), angel);
  8.     BufferedImage res = null;
  9.     res = new BufferedImage(rect_des.width, rect_des.height,
  10.             BufferedImage.TYPE_INT_RGB);
  11.     Graphics2D g2 = res.createGraphics();
  12.     // transform
  13.     g2.translate((rect_des.width - src_width) / 2,
  14.             (rect_des.height - src_height) / 2);
  15.     g2.rotate(Math.toRadians(angel), src_width / 2, src_height / 2);
  17.     g2.drawImage(src, null, null);
  18.     return res;
  19. }
  21. public static Rectangle calcRotatedSize(Rectangle src, int angel) {
  22.     // if angel is greater than 90 degree, we need to do some conversion
  23.     if (angel >= 90) {
  24.         if(angel / 90 % 2 == 1){
  25.             int temp = src.height;
  26.             src.height = src.width;
  27.             src.width = temp;
  28.         }
  29.         angel = angel % 90;
  30.     }
  32.     double r = Math.sqrt(src.height * src.height + src.width * src.width) / 2;
  33.     double len = 2 * Math.sin(Math.toRadians(angel) / 2) * r;
  34.     double angel_alpha = (Math.PI - Math.toRadians(angel)) / 2;
  35.     double angel_dalta_width = Math.atan((double) src.height / src.width);
  36.     double angel_dalta_height = Math.atan((double) src.width / src.height);
  38.     int len_dalta_width = (int) (len * Math.cos(Math.PI - angel_alpha
  39.             - angel_dalta_width));
  40.     int len_dalta_height = (int) (len * Math.cos(Math.PI - angel_alpha
  41.             - angel_dalta_height));
  42.     int des_width = src.width + len_dalta_width * 2;
  43.     int des_height = src.height + len_dalta_height * 2;
  44.     return new java.awt.Rectangle(new Dimension(des_width, des_height));
  45. }
  47. public static void main(String[] args) throws IOException {
  48.     BufferedImage src = ImageIO.read(new File("/Users/pzblog/Desktop/11.jpeg"));
  49.     BufferedImage des = RotateImage.rotate(src, 90);
  50.     ImageIO.write(des, "jpg", new File("/Users/pzblog/Desktop/11-rotate.jpeg"));
  51. }

}

  2. - 最后给回正后的图像添加水印
  3. ```java
  4. public static void main(String[] args) {
  5.     String srcImgPath = "/Users/pzblog/Desktop/11-rotate.jpeg"; //原始文件地址
  6.     String targetImgPath = "/Users/pzblog/Desktop/1-rotate-copy.jpg"; //目标文件地址
  7.     String text = "复 印 无 效"; //水印文字内容
  8.     Color color = Color.red; //水印文字颜色
  9.     Font font = new Font("宋体", Font.BOLD, 60); //水印文字字体
  10.     float alpha = 0.4f; //水印透明度
  11.     int positionWidth = 320; //水印横向位置坐标
  12.     int positionHeight = 450; //水印纵向位置坐标
  13.     Integer degree = -30; //水印旋转角度
  14.     String location = "center"; //水印的位置
  15.     //给图片添加文字水印
  16.     markImage(srcImgPath, targetImgPath, text, color, font, alpha, positionWidth, positionHeight, degree, location);
  17. }

输入结果：
Java给图像加水印 - 图7
添加水印的结果与预期一致！