• Java 基于Graphics2D 实现海报（支持自定义颜色，背景，logo,贴图）

    效果：

    海报一：

    海报二：

    代码：

    参数实体类：

    1. package com.ly.cloud.dto;
    2.  
    3. import lombok.Data;
    4.  
    5. /**
    6.  * @Author  
    7.  * @Date  Created in  2024/4/24 下午2:16
    8.  * @DESCRIPTION:   海报页面所需的参数 实体类
    9.  * @Version  V1.0
    10.  */
    11. @Data
    12. public class PosterTemplateDto {
    13.     /**
    14.      * 用来判断是不是 需要把数据写死 0 写死的对象，1 自己传的
    15.      */
    16.     private String id;
    17.     {
    18.         id = "0";
    19.     }
    20.     /**
    21.      * 海报编号  0: 横向海报   1: 竖向海报
    22.      */
    23.     private String posterId;
    24.  
    25.     /**
    26.      * 海报颜色 0: 绿色  1: 蓝色  2: 红色
    27.      */
    28.     private String posterColor;
    29.     /**
    30.      * 海报背景图片名称
    31.      */
    32.     private String posterBackImage;
    33.  
    34.     /**
    35.      * 海报logo
    36.      */
    37.     private String posterLogo;
    38.     /**
    39.      * 海报主题  xxxx 第 x 期
    40.      */
    41.     private String posterTopic;
    42.  
    43.     /**
    44.      * 海报标题
    45.      */
    46.     private String posterTitle;
    47.  
    48.     /**
    49.      * 海报年份
    50.      */
    51.     private String posterYear;
    52.  
    53.     /**
    54.      * 海报具体时间  几月几号
    55.      */
    56.     private String posterMonth;
    57.  
    58.     /**
    59.      * 海报具体时间 14:30 ~ 15:30(周四)
    60.      */
    61.     private String posterDay;
    62.  
    63.     /**
    64.      * 讲座就行校区
    65.      */
    66.     private String posterSchool;
    67.     /**
    68.      * 讲座的具体地址
    69.      */
    70.     private String posterAddress;
    71.  
    72.     /**
    73.      * 讲座主讲人
    74.      */
    75.     private String posterMainSpeaker;
    76.  
    77.     /**
    78.      * 主讲人个人详细信息介绍
    79.      */
    80.     private String posterPeopleDetail;
    81.  
    82.     /**
    83.      * 主持人
    84.      */
    85.     private String mainPeople;
    86. }

    工具类：

    FileUtil.java
    1. package com.ly.cloud.util;
    2.  
    3. import com.alibaba.druid.support.logging.Log;
    4. import com.alibaba.druid.support.logging.LogFactory;
    5. import org.springframework.web.multipart.MultipartFile;
    6.  
    7. import javax.imageio.ImageIO;
    8. import java.awt.*;
    9. import java.awt.image.BufferedImage;
    10. import java.io.*;
    11. import java.nio.file.Files;
    12.  
    13. /**
    14.  * @Author  
    15.  * @Date  Created in  2024/4/11 上午11:13
    16.  * @DESCRIPTION:   将 multipartFile --> file
    17.  * @Version  V1.0
    18.  */
    19. public class FileUtil {
    20.  
    21.     private final static Log logger = LogFactory.getLog(FileUtil.class);
    22.  
    23.  
    24.     /**
    25.      * 将 multipartFile -->  fileInputStream
    26.      */
    27.     public static FileInputStream convertMultipartFileToInputStream(MultipartFile multipartFile) throws IOException {
    28.         // 创建临时文件
    29.         File tempFile = File.createTempFile("temp", null);
    30.  
    31.         // 将MultipartFile的数据写入临时文件
    32.         try (FileOutputStream fos = new FileOutputStream(tempFile)) {
    33.             fos.write(multipartFile.getBytes());
    34.         }
    35.  
    36.         // 将临时文件转换为FileInputStream
    37.         FileInputStream fileInputStream = new FileInputStream(tempFile);
    38.  
    39.         // 删除临时文件
    40.         tempFile.delete();
    41.  
    42.         return fileInputStream;
    43.     }
    44.  
    45.     /**
    46.      * 将上传的 logo图片保存在本地；
    47.      */
    48.     public static File convertInputStreamToFile(InputStream inputStream,String fileName) throws IOException {
    49.         // 创建图片文件
    50.         String resourcesPath = new File("src/main/resources/").getAbsolutePath();
    51.         // 拼接images目录的路径
    52.         String imagesPath = resourcesPath + "/static/imagesLogo/"; // 这里的static是resources目录下的一个示例子目录，你可以根据实际情况修改
    53.         logger.info("我的路径是:{}"+imagesPath);
    54.         File directory = new File(imagesPath);
    55.         // 如果目标文件夹不存在，则创建它
    56.         if (!directory.exists()) {
    57.             directory.mkdirs();
    58.         }
    59.         File file = new File(directory, fileName);
    60.         try (OutputStream outputStream = Files.newOutputStream(file.toPath())) {
    61.             byte[] buffer = new byte[1024];
    62.             int length;
    63.             while ((length = inputStream.read(buffer)) != -1) {
    64.                 outputStream.write(buffer, 0, length);
    65.             }
    66.         }
    67. //        deleteImage(imagesPath,fileName);
    68.         return file;
    69.     }
    70.  
    71.     /**
    72.      * 删除图片
    73.      */
    74.     public static void deleteImage(String directoryPath, String imageName) {
    75.         File directory = new File(directoryPath);
    76.         if (!directory.exists() || !directory.isDirectory()) {
    77.             return;
    78.         }
    79.         File imageFile = new File(directory, imageName);
    80.         if (imageFile.exists() && imageFile.isFile()) {
    81.             if (imageFile.delete()) {
    82.                 logger.info("删除图片成功！");
    83.             } else {
    84.                 logger.error("删除图片失败！");
    85.             }
    86.         } else {
    87.             System.out.println("Image file " + imageName + " does not exist.");
    88.         }
    89.     }
    90.  
    91.     /**
    92.      * 修改图片的宽高 等比例扩大 海报背景图和 logo
    93.      */
    94.     public static byte[] resizeImage(byte[] imageData, int width, int height) throws IOException {
    95.         ByteArrayInputStream bis = new ByteArrayInputStream(imageData);
    96.         BufferedImage image = ImageIO.read(bis);
    97.  
    98.         Image resizedImage = image.getScaledInstance(width, height, Image.SCALE_SMOOTH);
    99.  
    100.         BufferedImage bufferedResizedImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
    101.         bufferedResizedImage.getGraphics().drawImage(resizedImage, 0, 0, null);
    102.  
    103.         ByteArrayOutputStream bos = new ByteArrayOutputStream();
    104.         ImageIO.write(bufferedResizedImage, "jpg", bos);
    105.         byte[] resizedImageData = bos.toByteArray();
    106.  
    107.         bis.close();
    108.         bos.close();
    109.  
    110.         return resizedImageData;
    111.     }
    112. //    public static void main(String[] args) throws IOException {
    113. //        String resourcesPath = new File("src/main/resources/").getAbsolutePath();
    114. //        // 拼接images目录的路径
    115. //        String imagesPath = resourcesPath + "/static/images/"; // 这里的static
    116. //
    117. //        // 读取背景图片
    118. //        BufferedImage backgroundImage = ImageIO.read(new File(imagesPath + "/" + "4c9a599ae920240424112637.png"));
    119. //        ImageIO.write(backgroundImage, "PNG", new File("D:\\test1\\image.png"));
    120. //
    121. //    }
    122. }
    PosterUtil.java 
    1. package com.ly.cloud.util;
    2.  
    3. import sun.font.FontDesignMetrics;
    4.  
    5. import java.awt.*;
    6. import java.awt.geom.AffineTransform;
    7. import java.awt.geom.Ellipse2D;
    8. import java.awt.image.BufferedImage;
    9.  
    10. /**
    11.  * @Author  
    12.  * @Date  Created in  2024/4/24 下午2:45
    13.  * @DESCRIPTION:    海报工具类
    14.  * @Version  V1.0
    15.  */
    16.  
    17. public class PosterUtil {
    18.  
    19.     /**
    20.      * 从新设置海报图片的宽和高
    21.      * @param originalImage 原始图片
    22.      * @param targetWidth 宽
    23.      * @param targetHeight 高
    24.      * @return BufferedImage
    25.      */
    26.     public static BufferedImage scaleImage(BufferedImage originalImage, int targetWidth, int targetHeight) {
    27.         int type = originalImage.getType() == 0 ? BufferedImage.TYPE_INT_ARGB : originalImage.getType();
    28.         BufferedImage scaledImage = new BufferedImage(targetWidth, targetHeight, type);
    29.         Graphics2D g = scaledImage.createGraphics();
    30.         // Calculate the ratio between the original and scaled image size
    31.         double scaleX = (double) targetWidth / originalImage.getWidth();
    32.         double scaleY = (double) targetHeight / originalImage.getHeight();
    33.         double scale = Math.min(scaleX, scaleY);
    34.         // Now we perform the actual scaling
    35.         int newWidth = (int) (originalImage.getWidth() * scale);
    36.         int newHeight = (int) (originalImage.getHeight() * scale);
    37.         int x = (targetWidth - newWidth) / 2;
    38.         int y = (targetHeight - newHeight) / 2;
    39.         g.drawImage(originalImage.getScaledInstance(newWidth, newHeight, Image.SCALE_SMOOTH), x, y, null);
    40.         g.dispose();
    41.         return scaledImage;
    42.     }
    43.  
    44.     /**
    45.      * @Author  
    46.      * @Description  海报横向文字写字换行算法
    47.      * @Date  18:08 2024/4/24
    48.      * @Param 参数 Graphics2D 对象 、font 字体设置 、 文字、 x轴左边、 y轴坐标 、每行字体的换行宽度
    49.      **/
    50.     public static void drawWordAndLineFeed(Graphics2D g2d, Font font, String words, int wordsX, int wordsY, int wordsWidth) {
    51.         FontDesignMetrics metrics = FontDesignMetrics.getMetrics(font);
    52.         // 获取字符的最高的高度
    53.         int height = metrics.getHeight();
    54.  
    55.         int width = 0;
    56.         int count = 0;
    57.         int total = words.length();
    58.         String subWords = words;
    59.         int b = 0;
    60.         for (int i = 0; i < total; i++) {
    61.             // 统计字符串宽度 并与 预设好的宽度 作比较
    62.             if (width <= wordsWidth) {
    63.                 width += metrics.charWidth(words.charAt(i)); // 获取每个字符的宽度
    64.                 count++;
    65.             } else {
    66.                 // 画 除了最后一行的前几行
    67.                 String substring = subWords.substring(0, count);
    68.                 g2d.drawString(substring, wordsX, wordsY + (b * height));
    69.                 subWords = subWords.substring(count);
    70.                 b++;
    71.                 width = 0;
    72.                 count = 0;
    73.             }
    74.             // 画 最后一行字符串
    75.             if (i == total - 1) {
    76.                 g2d.drawString(subWords, wordsX, wordsY + (b * height));
    77.             }
    78.         }
    79.     }
    80.  
    81.     /**
    82.      * 将上传的个人头像裁剪成对应的海报比例的头像，并裁剪成圆形
    83.      * @param image 读取的头像找
    84.      * @param size  宽高大小像素
    85.      * @return BufferedImage
    86.      */
    87.     public static BufferedImage resizeAndClipToCircle(BufferedImage image, int size) {
    88.         // 缩小图片
    89.         BufferedImage resizedImage = new BufferedImage(size, size, BufferedImage.TYPE_INT_ARGB);
    90.         Graphics2D g2d = resizedImage.createGraphics();
    91.         g2d.drawImage(image, 0, 0, size, size, null);
    92.         g2d.dispose();
    93.  
    94.         // 裁剪成圆形
    95.         BufferedImage circularImage = new BufferedImage(size, size, BufferedImage.TYPE_INT_ARGB);
    96.         Graphics2D g2d2 = circularImage.createGraphics();
    97.         Ellipse2D.Double ellipse = new Ellipse2D.Double(0, 0, size, size);
    98.         g2d2.setClip(ellipse);
    99.         g2d2.drawImage(resizedImage, 0, 0, size, size, null);
    100.         g2d2.dispose();
    101.  
    102.         return circularImage;
    103.     }
    104.  
    105.     /**
    106.      * 部分文字 垂直排序时，不满多列，最后一列居中显示
    107.      * @param textGraphics Graphics 对象
    108.      * @param text  要传入的海报描述
    109.      */
    110.     public static void drawMyString(Graphics textGraphics, String text,Color color) {
    111.  
    112.         // 每列显示的汉字数量
    113.         int columnSize = 7;
    114.         // 文字之间的垂直间距
    115.         int verticalSpacing = 75;
    116.  
    117.         // 获取字体渲染上下文
    118.         FontMetrics fm = textGraphics.getFontMetrics();
    119.         // 获取字体的高度
    120.         int fontHeight = fm.getHeight();
    121.         System.out.println(fontHeight);
    122.         // 计算每列的宽度
    123.         int columnWidth = fontHeight + verticalSpacing;
    124.  
    125.         // 设置初始位置
    126.         int x = 280;
    127.         int y = 450;
    128.         Font fontFour = new Font(" Source Han Sans CN", Font.BOLD, 100);
    129.         textGraphics.setFont(fontFour);
    130.         textGraphics.setColor(color);
    131.         // 绘制文字
    132.         int charCount = 0;
    133.         int totalColumns = (int)Math.ceil((double)text.length() / columnSize); // 总列数
    134.         int totalRows = Math.min(columnSize, text.length()); // 总行数
    135.         int remainingChars = text.length() % columnSize; // 最后一列剩余字符数
    136.  
    137.         for (int columnIndex = 0; columnIndex < totalColumns; columnIndex++) {
    138.             for (int rowIndex = 0; rowIndex < totalRows; rowIndex++) {
    139.                 if (charCount >= text.length()) break;
    140.                 char ch = text.charAt(charCount);
    141.                  // 计算当前位置
    142.                 int cx = x - columnIndex * columnWidth;
    143.                 int cy = y + rowIndex * fontHeight + rowIndex * verticalSpacing; // 加入垂直偏移量
    144.                  // 计算当前位置
    145. //                int cx = x - columnIndex * columnWidth;
    146. //                int cy = y + rowIndex * fontHeight + rowIndex * verticalSpacing + columnIndex ;
    147.  
    148.                 // 如果是最后一列并且不满 7 个字符，则需要将剩余字符居中
    149.                 if (columnIndex == totalColumns - 1 && remainingChars > 0) {
    150.                     int extraVerticalSpace = (columnSize - remainingChars) * (fontHeight + verticalSpacing) / 2;
    151.                     cy += extraVerticalSpace;
    152.                 }
    153.                 // 绘制文字
    154.                 textGraphics.drawString(String.valueOf(ch), cx, cy);
    155.                 charCount++;
    156.             }
    157.         }
    158.     }
    159.  
    160.     /**
    161.      * 横向显示 垂直文字
    162.      * @param textGraphics Graphics 对象
    163.      * @param text   显示的 内容
    164.      * @param number 没列显示汉字数量
    165.      */
    166.     public static void drawString(Graphics textGraphics,String text,int number){
    167.  
    168.         // 每列显示的汉字数量
    169.         int columnSize = number;
    170.         // 文字之间的垂直间距
    171.         int verticalSpacing = 50;
    172.  
    173.         // 获取字体渲染上下文
    174.         FontMetrics fm = textGraphics.getFontMetrics();
    175.         // 获取字体的高度
    176.         int fontHeight = fm.getHeight();
    177.  
    178.         // 计算每列的宽度
    179.         int columnWidth = fontHeight + verticalSpacing;
    180.  
    181.         // 设置初始位置
    182.         int x = 0;
    183.         int y = 0;
    184.         switch (number) {
    185.             case 3:
    186.                 x = 1250;
    187.                 y = 790;
    188.                 break;
    189.             case 10:
    190.                 x = 1150;
    191.                 y = 800;
    192.                 break;
    193.             // 可以添加更多的条件分支
    194.             default:
    195.                 // 默认情况下的坐标设置
    196.                 break;
    197.         }
    198.         if (number == 10) {
    199.             Font fontFour = new Font(text, Font.BOLD, 60);
    200.             textGraphics.setFont(fontFour);
    201.             textGraphics.setColor(Color.WHITE);
    202.         }
    203.         // 绘制文字
    204.         for (int i = 0; i < text.length(); i++) {
    205.  
    206.             char ch = text.charAt(i);
    207.             // 计算当前位置
    208.             int cx = x - (i / columnSize) * columnWidth;
    209.             int cy = y + (i % columnSize) * fontHeight;
    210.             // 绘制文字
    211.             textGraphics.drawString(String.valueOf(ch), cx, cy);
    212.         }
    213.     }
    214.  
    215.     public static void drawCenteredText(Graphics graphics, String text, int oneY, int twoY) {
    216.         // 设置字体和颜色
    217.         Font font = new Font("宋体", Font.BOLD, 50);
    218.         graphics.setFont(font);
    219.         graphics.setColor(Color.WHITE);
    220.         // 获取字体渲染上下文
    221.         FontMetrics fm = graphics.getFontMetrics(font);
    222.         // 截取第二行文字的部分
    223.         String textTwo = text.substring(text.indexOf("第"));
    224.         // 获取第一行文字的宽度
    225.         String textOne = text.substring(0, text.indexOf("第"));
    226.         // 获取第二行文字的宽度
    227.         int textTwoWidth = fm.stringWidth(textTwo);
    228.         // 计算第一行文字的起始x坐标，使其水平居中
    229.         int oneX = 50;
    230.         // 计算第二行文字的起始x坐标，使其水平居中
    231.         int twoX = (450 - textTwoWidth) / 2;
    232.         // 绘制第一行文字
    233.         graphics.drawString(textOne, oneX, oneY);
    234.         // 绘制第二行文字
    235.         graphics.drawString(textTwo, twoX, twoY);
    236.     }
    237.     /**
    238.      * 在Graphics2D对象上绘制竖排文字
    239.      *
    240.      * @param textGraphics     Graphics2D对象
    241.      * @param text            要绘制的文字
    242.      */
    243.     public static void drawMyLectureString(Graphics textGraphics, String text) {
    244.  
    245.         // 每列显示的汉字数量
    246.         int columnSize = 25;
    247.         // 文字之间的垂直间距
    248.         int verticalSpacing = 1;
    249.  
    250.         // 获取字体渲染上下文
    251.         FontMetrics fm = textGraphics.getFontMetrics();
    252.         // 获取字体的高度
    253.         int fontHeight = fm.getHeight() - 30;
    254.  
    255.         // 计算每列的宽度
    256.         int columnWidth = fontHeight + verticalSpacing;
    257.  
    258.         // 设置初始位置
    259.         int x = 800;
    260.         int y = 190;
    261.         Font fontFour = new Font("宋体", Font.BOLD, 40);
    262.         textGraphics.setFont(fontFour);
    263.         textGraphics.setColor(Color.WHITE);
    264.  
    265.         // 计算总列数
    266.         int totalColumns = (int) Math.ceil((double) text.length() / columnSize); // 总列数
    267.  
    268.         // 绘制文字
    269.         int charCount = 0;
    270.         for (int rowIndex = 0; rowIndex < columnSize; rowIndex++) {
    271.             for (int columnIndex = 0; columnIndex < totalColumns; columnIndex++) {
    272.                 int charIndex = rowIndex * totalColumns + columnIndex;
    273.                 if (charIndex >= text.length()) break;
    274.                 char ch = text.charAt(charIndex);
    275.                 // 计算当前位置
    276.                 int cx = x - columnIndex * columnWidth;
    277.                 int cy = y + rowIndex * fontHeight + rowIndex * verticalSpacing; // 加入垂直偏移量
    278.                 // 绘制文字
    279.                 textGraphics.drawString(String.valueOf(ch), cx, cy);
    280.             }
    281.         }
    282.     }
    283.  
    284.  
    285.     /**
    286.      * 字体倾斜
    287.      */
    288.     public static void qinxie(Font fontMonth,Graphics2D graphics){
    289.         // 创建 AffineTransform 对象
    290.         AffineTransform month = new AffineTransform();
    291.         // 设置水平倾斜
    292.         month.shear(-0.2, 0); // + 向左  -  向右倾斜
    293.         // 应用变换到字体
    294.         fontMonth = fontMonth.deriveFont(month);
    295.         graphics.setFont(fontMonth);
    296.     }
    297.  
    298.     /**
    299.      * 文字垂直
    300.      */
    301.     public static void drawSecondString(Graphics textGraphics, String text, int number) {
    302.  
    303.         // 每列显示的汉字数量
    304.         int columnSize = number;
    305.         // 文字之间的垂直间距
    306.         int verticalSpacing = columnSize == 15 ? -500 : 50;
    307.         // 获取字体渲染上下文
    308.         FontMetrics fm = textGraphics.getFontMetrics();
    309.         // 获取字体的高度
    310.         int fontHeight = fm.getHeight();
    311.  
    312.         // 计算每列的宽度
    313.         int columnWidth = columnSize == 15 ? 60 : fontHeight + verticalSpacing;
    314.  
    315.         // 设置初始位置
    316.         int x = 0;
    317.         int y = 0;
    318.         switch (number) {
    319.             case 3:
    320.                 x = 1100;
    321.                 y = 200;
    322.                 break;
    323.             case 10:
    324.                 x = 1000;
    325.                 y = 210;
    326.                 break;
    327.             case 15:
    328.                 x = 800;
    329.                 y = 210;
    330.                 break;
    331.             // 可以添加更多的条件分支
    332.             default:
    333.                 // 默认情况下的坐标设置
    334.                 break;
    335.         }
    336.         if (number == 10) {
    337.             Font fontFour = new Font(text, Font.BOLD, 60);
    338.             textGraphics.setFont(fontFour);
    339.             textGraphics.setColor(Color.WHITE);
    340.         } else if (number == 15) {
    341.             Font fontFour = new Font(text, Font.BOLD, 40);
    342.             textGraphics.setFont(fontFour);
    343.             textGraphics.setColor(Color.WHITE);
    344.         }
    345.         // 绘制文字
    346.         for (int i = 0; i < text.length(); i++) {
    347.  
    348.             char ch = text.charAt(i);
    349.             // 计算当前位置
    350.             int cx = x - (i / columnSize) * columnWidth;
    351.             int cy = y + (i % columnSize) * fontHeight;
    352.  
    353.             textGraphics.drawString(String.valueOf(ch), cx, cy);
    354.         }
    355.     }
    356.  
    357. }

    业务代码：

    首先新建3个目录用来存放一下固定的背景图片和 临时的文件

     generatePosterTemplate.java
    1.  @Override
    2.     public Map generatePosterTemplate(PosterTemplateDto template) throws IOException {
    3.         // 首先读取文件的路径
    4.         String imagesPath = new File("src/main/resources/").getAbsolutePath() + "/static/imagesFirst/";
    5.         String imagesPathSecond = new File("src/main/resources/").getAbsolutePath() + "/static/imagesSecond/";
    6.         String imagesPathLogo = new File("src/main/resources/").getAbsolutePath() + "/static/imagesLogo/";
    7.         String temp = new File("src/main/resources/").getAbsolutePath() + "/static/temp/";
    8.  
    9.         // 创建颜色并设置透明度
    10.         Map map = new HashMap<>();
    11.         map.put("0", new Color(0, 88, 38));
    12.         map.put("1", new Color(40, 50, 112));
    13.         map.put("2", new Color(129, 2, 3));
    14.         Color color = map.getOrDefault(template.getPosterColor(), new Color(0, 88, 38));
    15.         Map fileMap = new HashMap<>();
    16.         String fileName = IdUtil.simpleUUID().substring(0, 10) + DateTimeUtils.stringTime();
    17.  
    18.         PosterTemplateDto posterTemplate = "0".equals(template.getId())
    19.                 ? createPosterTemplate(template) : template;
    20.         try {
    21.             // 读取背景图片
    22.             if ("0".equals(template.getPosterId())) {
    23.                 // 横向海报
    24.                 // 读取海报背景图片    BufferedImage backgroundImage = ImageIO.read(new File("D:\\test1\\backImage.png"));
    25.                 File originalBackFile = new File(StrUtil.isNotBlank(template.getPosterBackImage())
    26.                         ? getUpdatePhotoPath(imagesPathLogo, template.getPosterBackImage(), 1372, 1978) : imagesPath + "backImage.png");
    27.                 BufferedImage backgroundImage = ImageIO.read(originalBackFile);
    28.                 if (StrUtil.isNotBlank(template.getPosterBackImage())) {
    29.                     // 将保存到本地的图片名称返回给我
    30.                     fileMap.put("backImage", template.getPosterBackImage());
    31.                 }
    32.  
    33.                 int alpha = 180; // 透明度（取值范围：0 - 255）
    34.  
    35.                 // 创建 Graphics2D 对象
    36.                 Graphics2D g2d = backgroundImage.createGraphics();
    37.  
    38.                 // 设置透明度
    39.                 AlphaComposite alphaComposite = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, (float) alpha / 255);
    40.                 g2d.setComposite(alphaComposite);
    41.  
    42.                 // 设置背景色
    43.                 g2d.setColor(color);
    44.  
    45.                 // 填充整个图片区域
    46.                 g2d.fillRect(0, 0, backgroundImage.getWidth(), backgroundImage.getHeight());
    47.  
    48.                 // 读取要贴的第一张小图片 "D:\\test1\\schoolLogo.png"
    49.                 File originalFile = new File(imagesPath + "schoolLogo.png");
    50.                 BufferedImage image = ImageIO.read(originalFile);
    51.                 // 调用 resizeImageOne 方法进行放大
    52.                 BufferedImage overlayImage1 = PosterUtil.scaleImage(image, 200, 90);
    53.  
    54.                 // 读取要贴的第二张小图片
    55.                 BufferedImage overlayImage2 = ImageIO.read(new File(StrUtil.isNotBlank(template.getPosterLogo())
    56.                         ? getUpdatePhotoPath(imagesPathLogo, template.getPosterLogo(), 670, 66) : imagesPath + "collegeLogo.png"));
    57.                 if (StrUtil.isNotBlank(template.getPosterLogo())) {
    58.                     // 将保存到本地的图片名称返回给我
    59.                     fileMap.put("logo", template.getPosterLogo());
    60.                 }
    61.  
    62.                 // 读取要贴的第三张小图片
    63.                 BufferedImage overlayImage3 = ImageIO.read(new File(imagesPath + "erweima.png"));
    64.  
    65.                 // 读取头像图片
    66.                 BufferedImage avatarImage = ImageIO.read(new File(imagesPath + "touxiang.png"));
    67.  
    68.                 // 缩小第五张图片并裁剪成圆形
    69.                 BufferedImage scaledCircularAvatar = PosterUtil.resizeAndClipToCircle(avatarImage, 400);
    70.  
    71.                 // 计算贴图位置
    72.                 // 在背景图片上贴上第一张图片
    73.                 createImage(backgroundImage, overlayImage1, 50, 60);
    74.                 // 在背景图片上贴上第二张图片
    75.                 createImage(backgroundImage, overlayImage2, 280, 70);
    76.                 // 在背景图片上贴上第三张图片
    77.                 createImage(backgroundImage, overlayImage3, 50, 1200);
    78.                 // 在背景图片上贴上缩小并且裁剪成圆形后的头像图片
    79.                 createImage(backgroundImage, scaledCircularAvatar, 790, 800);
    80.                 // 在图片上写字
    81.                 // TODO 创建Graphics对象
    82.                 Graphics2D graphics = backgroundImage.createGraphics();
    83.  
    84.                 // 设置第一行字体和颜色：添加海报主题文字
    85.                 Font font = new Font("", Font.BOLD, 50);
    86.                 graphics.setFont(font);
    87.                 graphics.setColor(Color.WHITE);
    88.                 graphics.drawString(posterTemplate.getPosterTopic(), 50, 280);
    89.  
    90.                 // 设置第二行的字体和颜色
    91.                 // TODO 添加第二行文字
    92.                 Font fontTwo = new Font("", Font.BOLD, 140);
    93.                 graphics.setFont(fontTwo);
    94.                 graphics.setColor(Color.WHITE);
    95.                 PosterUtil.drawWordAndLineFeed(graphics, fontTwo, posterTemplate.getPosterTitle(), 45, 480, 1200);
    96.  
    97.  
    98.                 // TODO 添加第三行文字 具体地址文字
    99.                 Font fontThree = new Font("", Font.BOLD, 65);
    100.                 graphics.setFont(fontThree);
    101.                 graphics.setColor(Color.WHITE);
    102.                 graphics.drawString(posterTemplate.getPosterAddress(), 43, 1800);
    103.  
    104.                 // TODO 添加第四行文字 校区 地址文字
    105.                 Font fontFour = new Font("", Font.BOLD, 45);
    106.                 graphics.setFont(fontFour);
    107.                 graphics.setColor(Color.WHITE);
    108.                 graphics.drawString(posterTemplate.getPosterSchool(), 48, 1870);
    109.  
    110.                 //主讲人
    111.                 PosterUtil.drawString(graphics, "主讲人", 3);
    112.                 PosterUtil.drawString(graphics, posterTemplate.getPosterMainSpeaker(), 10);
    113.  
    114.                 // TODO 1.18 日期
    115.                 Font fontDate = new Font("", Font.BOLD, posterTemplate.getPosterMonth().length() == 4 ? 150 : 120);
    116.                 graphics.setFont(fontDate);
    117.                 graphics.setColor(Color.WHITE);
    118.                 graphics.drawString(posterTemplate.getPosterMonth(), 135, 900);
    119.  
    120.                 // TODO  14:30 ~ 15:30  (周四)
    121.                 Font fontMinutes = new Font("", Font.BOLD, 60);
    122.                 graphics.setFont(fontMinutes);
    123.                 graphics.setColor(Color.WHITE);
    124.                 PosterUtil.drawWordAndLineFeed(graphics, fontMinutes, posterTemplate.getPosterDay(), 50, 970, 350);
    125.  
    126.                 // TODO 添加海报的文字日期 2024 年份
    127.                 int yearX = 55; // 文字起始位置 x 坐标
    128.                 int yearY = 930; // 文字起始位置 y 坐标
    129.                 Font yearFont = new Font("", Font.BOLD, 50);
    130.                 // 设置渲染提示以获得更好的质量
    131.                 graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    132.  
    133.                 // 创建一个 AffineTransform 对象，并将其设置为顺时针旋转90度
    134.                 AffineTransform at = new AffineTransform();
    135.                 at.setToRotation(Math.PI / 2.0, yearX, yearY);
    136.  
    137.                 // 应用 AffineTransform 对象
    138.                 graphics.setTransform(at);
    139.  
    140.                 // 获取字体渲染上下文
    141.                 FontRenderContext frc = graphics.getFontRenderContext();
    142.                 // 获取文本宽度
    143.                 int textWidth = (int) graphics.getFont().getStringBounds(posterTemplate.getPosterYear(), frc).getWidth();
    144.  
    145.                 // 调整起始位置，以确保文本在旋转后完全可见
    146.                 yearX -= textWidth;
    147.                 graphics.setFont(yearFont);
    148.                 // 绘制文字
    149.                 graphics.drawString(posterTemplate.getPosterYear(), yearX, yearY);
    150.  
    151.                 // 释放Graphics对象
    152.                 graphics.dispose();
    153.                 InsertMinio(temp, backgroundImage, fileName, fileMap);
    154.             } else {
    155.                 // 竖向 排版海报
    156.                 // 读取背景图片 getUpdatePhotoPath(imagesPathLogo, template.getPosterLogo(), 670, 66)
    157.                 File originalBackFile = new File(StrUtil.isNotBlank(template.getPosterBackImage())
    158.                         ? getUpdatePhotoPath(imagesPathLogo, template.getPosterBackImage(), 1472, 2102) : imagesPathSecond + "backImageSecondTwo.png");
    159.                 if (StrUtil.isNotBlank(template.getPosterBackImage())) {
    160.                     // 将保存到本地的图片名称返回给我
    161.                     fileMap.put("backImage", template.getPosterBackImage());
    162.                 }
    163.                 BufferedImage backgroundImage = ImageIO.read(originalBackFile);
    164.                 // 创建颜色并设置透明度
    165.                 int alpha = 240; // 透明度（取值范围：0 - 255）
    166.                 // 创建 Graphics2D 对象
    167.                 Graphics2D g2d = backgroundImage.createGraphics();
    168.  
    169.                 // 设置透明度
    170.                 AlphaComposite alphaComposite = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, (float) alpha / 255);
    171.                 g2d.setComposite(alphaComposite);
    172.                 // 设置左上角背景色
    173.                 g2d.setColor(color);
    174.                 // 填充整个图片区域
    175.                 g2d.fillRect(0, 0, 450, 230);
    176.                 // 设置背景色
    177.                 Graphics2D g3d = backgroundImage.createGraphics();
    178.                 // 设置最下面的背景色
    179.                 g3d.setColor(color);
    180.                 // 填充整个图片区域
    181.                 g3d.fillRect(0, 1980, backgroundImage.getWidth(), 230);
    182.                 // 读取要贴的第一张小图片
    183.                 File originalFile = new File(imagesPathSecond + "schoolImageLogo.png");
    184.                 BufferedImage image = ImageIO.read(originalFile);
    185.                 // 调用 resizeImageOne 方法进行放大
    186.                 int width = 280;
    187.                 int height = 230;
    188.                 BufferedImage overlayImage1 = PosterUtil.scaleImage(image, width, height);
    189.  
    190.                 // 读取要贴的第二张小图片
    191.                 BufferedImage overlayImage2 = ImageIO.read(new File(imagesPathSecond + "back2.png"));
    192.  
    193.                 // 读取要贴的第三张小图片
    194.                 Map hashMap = new HashMap<>();
    195.                 hashMap.put("0", "green.png");
    196.                 hashMap.put("1", "blue.png");
    197.                 hashMap.put("2", "red.png");
    198.                 BufferedImage overlayImage3 = ImageIO.read(new File(imagesPathSecond + hashMap.getOrDefault(template.getPosterColor(), "green.png")));
    199.  
    200.                 BufferedImage overlayImage4 = ImageIO.read(new File(imagesPathSecond + hashMap.getOrDefault(template.getPosterColor(), "green.png")));
    201.                 // 读取头像图片
    202.                 BufferedImage avatarImage = ImageIO.read(new File(imagesPathSecond + "touxiang.png"));
    203.                 // 读取二维码
    204.                 File erweima = new File(imagesPathSecond + "erweima.png");
    205.                 BufferedImage erweimalogo = ImageIO.read(erweima);
    206.                 BufferedImage erweimaLogo = PosterUtil.scaleImage(erweimalogo, 200, 200);
    207.  
    208.                 // 缩小第六张图片并裁剪成圆形
    209.                 BufferedImage scaledCircularAvatar = PosterUtil.resizeAndClipToCircle(avatarImage, 400);
    210.  
    211.                 // 读取学校logo
    212.                 File schoolLogo = new File(imagesPathSecond + "schoolLogo.png");
    213.                 BufferedImage logo = ImageIO.read(schoolLogo);
    214.                 // 调用 resizeImageOne 方法进行放大
    215.                 BufferedImage imageLogo = PosterUtil.scaleImage(logo, 200, 100);
    216.  
    217.                 // 读取学院logo getUpdatePhotoPath(imagesPathSecond, template.getPosterLogo(), 1472, 2102) 440 118
    218.  
    219.                 // 读取学院logo
    220.                 BufferedImage images;
    221.                 if (StrUtil.isNotBlank(template.getPosterLogo())) {
    222.                     File collegeLogo = new File(getUpdatePhotoPath(imagesPathLogo, template.getPosterLogo(), 200, 100));
    223.                     if (StrUtil.isNotBlank(template.getPosterLogo())) {
    224.                         // 将保存到本地的图片名称返回给我
    225.                         fileMap.put("logo", template.getPosterLogo());
    226.                     }
    227.                     images = ImageIO.read(collegeLogo);
    228.                 } else {
    229.                     File collegeLogos = new File(imagesPathSecond + "collegelogos.png");
    230.                     BufferedImage collegeImage = ImageIO.read(collegeLogos);
    231.                     // 调用 resizeImageOne 方法进行放大
    232.                     images = PosterUtil.scaleImage(collegeImage, 200, 100);
    233.                 }
    234.  
    235.                 // 读取白色圆圈
    236.                 File yuan = new File(imagesPathSecond + "yuan.png");
    237.                 BufferedImage yuanImage = ImageIO.read(yuan);
    238.                 // 调用 resizeImageOne 方法进行放大
    239.                 BufferedImage imagesYuan = PosterUtil.scaleImage(yuanImage, 450, 450);
    240.  
    241.                 // 计算贴图位置  X,Y
    242.                 // 在背景图片上贴上第一张图片
    243.                 createImage(backgroundImage, overlayImage1, -5, 5);
    244.                 // 在背景图片上贴上第二张图片
    245.                 createImage(backgroundImage, overlayImage2, 0, 230);
    246.                 // 在背景图片上贴上第三张图片
    247.                 createImage(backgroundImage, overlayImage3, 50, 1400);
    248.                 //在背景图片上贴上第四张图片
    249.                 createImage(backgroundImage, overlayImage4, 50, 1580);
    250.                 // 在背景图片上贴上缩小并且裁剪成圆形后的头像图片
    251.                 createImage(backgroundImage, scaledCircularAvatar, 950, 370);
    252.                 //在背景图片上贴上第六张图片
    253.                 createImage(backgroundImage, erweimaLogo, 50, 1750);
    254.                 //在背景图片上贴上第7张图片
    255.                 createImage(backgroundImage, imageLogo, 900, 1990);
    256.                 //在背景图片上贴上第8张图片
    257.                 createImage(backgroundImage, images, 1200, 1990);
    258.                 //在背景图片上贴上第9张图片
    259.                 createImage(backgroundImage, imagesYuan, 925, 345);
    260.                 // 保存合成后的背景图片
    261.                 // TODO 标题
    262.                 Graphics2D graphics = backgroundImage.createGraphics();
    263.  
    264.                 // TODO 添加第二行文字
    265.                 Font fontTwo = new Font("", Font.BOLD, 50);
    266.                 graphics.setFont(fontTwo);
    267.                 graphics.setColor(Color.WHITE);
    268.                 String posterTopic = posterTemplate.getPosterTopic();
    269. //        drawWordAndLineFeed(graphics, fontTwo, textTwo, twoX, twoY, 320);
    270.                 PosterUtil.drawCenteredText(graphics, posterTopic, 100, 180);
    271.                 // TODO 主讲人信息
    272.                 PosterUtil.drawSecondString(graphics, "主讲人", 3);
    273.                 PosterUtil.drawSecondString(graphics, posterTemplate.getPosterMainSpeaker(), 10);
    274.  
    275.                 // TODO 主讲人详细介绍信息
    276.                 PosterUtil.drawMyLectureString(graphics, posterTemplate.getPosterPeopleDetail());
    277.                 // 设置字体和颜色
    278.                 Font font = new Font("宋体", Font.PLAIN, 50);
    279.                 g2d.setFont(font);
    280.                 g2d.setColor(Color.BLACK);
    281.                 // 绘制竖排文字
    282.  
    283.                 // TODO 讲座名称
    284.                 PosterUtil.drawMyString(graphics, posterTemplate.getPosterTitle(), color);
    285.  
    286.                 //TODO 时间 2024
    287.                 Font fontYear = new Font("Source Han Sans CN", Font.PLAIN, 40);
    288.                 graphics.setColor(Color.BLACK);
    289.                 PosterUtil.qinxie(fontYear, graphics);  //字体倾斜
    290.                 graphics.drawString(posterTemplate.getPosterYear(), 50, 1480);
    291.  
    292.  
    293.                 //TODO 时间 月份 10.23  1.23
    294.                 Font fontMonth = new Font("Source Han Sans CN", Font.BOLD, 75);
    295.                 graphics.setColor(Color.BLACK);
    296.                 PosterUtil.qinxie(fontMonth, graphics);
    297.                 String posterMonth = posterTemplate.getPosterMonth();
    298.                 graphics.drawString(posterMonth, posterMonth.length() == 5 ? 210 : 250, 1480);
    299.  
    300.                 //TODO 具体时间  20:12 ~ 11:00  周五
    301.                 Font fontDate = new Font("Source Han Sans CN", Font.PLAIN, 40);
    302.                 graphics.setColor(Color.BLACK);
    303.                 PosterUtil.qinxie(fontDate, graphics);
    304.                 graphics.drawString(posterTemplate.getPosterDay(), 50, 1550);
    305.  
    306.                 // TODO 具体举办地点
    307.                 Font fontDd = new Font("", Font.BOLD, 35);
    308.                 graphics.setFont(fontDd);
    309.                 graphics.setColor(Color.BLACK);
    310.                 PosterUtil.qinxie(fontDd, graphics);
    311.                 PosterUtil.drawWordAndLineFeed(graphics, fontDd, posterTemplate.getPosterAddress(), 50, 1630, 330);
    312.  
    313.                 // TODO 主持人
    314.                 Font zcr = new Font(" Source Han Sans CN", Font.PLAIN, 40);
    315.                 graphics.setColor(Color.white);
    316.                 graphics.setFont(zcr);
    317.                 String zcrName = "主持人: " + posterTemplate.getMainPeople();
    318.                 graphics.drawString(zcrName, 50, 2060);
    319.  
    320.                 // 设置抗锯齿
    321.                 graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    322.                 graphics.dispose();
    323.                 return InsertMinio(temp, backgroundImage, fileName, fileMap);
    324.             }
    325.         } catch (Exception e) {
    326.             throw new BusinessException(e.getMessage());
    327.         }
    328.         return fileMap;
    329.     }
    330. public void createImage(BufferedImage backgroundImage, BufferedImage imagesYuan, int x, int y) {
    331.         Graphics2D graphics9 = backgroundImage.createGraphics();
    332.         graphics9.drawImage(imagesYuan, x, y, null);
    333.         graphics9.dispose();
    334.     }
    335.  
    336.     public Map InsertMinio(String temp, BufferedImage backgroundImage, String fileName, Map fileMap) throws Exception {
    337.         File file = new File(temp);
    338.         ImageIO.write(backgroundImage, "PNG", file);
    339.         // 创建 FileInputStream 流
    340.         FileInputStream inputStream = new FileInputStream(file);
    341.  
    342.         // 现在你可以使用 inputStream 进行操作
    343.         minioUtil.uploadInputStream("mpbucket", "sjs/wdjz/hbgl" + SLASH_SUFFIX + fileName + ".png", inputStream);
    344.         InputStream download = minioUtil.download("mpbucket", "sjs/wdjz/hbgl" + SLASH_SUFFIX + fileName + ".png");
    345.         // 将删除的图片文件保存到本地
    346.         String name = fileName + ".png";
    347.         byte[] bytes = IOUtils.toByteArray(download);
    348.         String encoded = Base64.getEncoder().encodeToString(bytes);
    349.         fileMap.put("posterTemplate", name);
    350.         fileMap.put("code", BASE_64 + encoded);
    351.         // 记得关闭流
    352.         inputStream.close();
    353.         // 删除临时文件
    354.         file.delete();
    355.         return fileMap;
    356.     }
    357.  
    358.     /**
    359.      * 修改图片尺寸
    360.      *
    361.      * @return 新的海报地址
    362.      */
    363.     public String getUpdatePhotoPath(String path, String fileName, int width, int height) throws Exception {
    364.         File originalFile = new File(path + fileName);
    365.         byte[] originalImageData = Files.readAllBytes(originalFile.toPath());
    366.         byte[] resizedImageData = FileUtil.resizeImage(originalImageData, width, height);
    367.         // 将 byte[] 转换为 ByteArrayInputStream
    368.         ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(resizedImageData);
    369.         // 创建临时文件（如果需要）
    370.         File tempFile = File.createTempFile("temp", ".tmp");
    371.         // 将 ByteArrayInputStream 中的数据写入临时文件
    372.         IOUtils.copy(byteArrayInputStream, Files.newOutputStream(tempFile.toPath()));
    373.         // 使用临时文件创建 FileInputStream
    374.         FileInputStream fileInputStream = new FileInputStream(tempFile);
    375.         // 现在你可以使用 fileInputStream 对象进行操作
    376.         minioUtil.uploadInputStream("mpbucket", "sjs/wdjz/hbgl" + SLASH_SUFFIX + fileName, fileInputStream);
    377.         InputStream download = minioUtil.download("mpbucket", "sjs/wdjz/hbgl" + SLASH_SUFFIX + fileName);
    378.         // 将保存的logo 图片文件保存到本地
    379.         FileUtil.convertInputStreamToFile(download, fileName);
    380.         // 删除 minio中的图片
    381.         minioUtil.deleteFile("mpbucket", fileName);
    382.         // 关闭流和删除临时文件
    383.         fileInputStream.close();
    384.         tempFile.delete();
    385.         return path + fileName;
    386.     }
    387.     //写死两个模板所需要的参数
    388.     public PosterTemplateDto createPosterTemplate(PosterTemplateDto oldDto) {
    389.         if ("0".equals(oldDto.getPosterId())){
    390.             oldDto.setPosterTopic("物理与天文学院学术报告 第359期");
    391.             oldDto.setPosterTitle("MIMO天线及其空口测试技术");
    392.             oldDto.setPosterYear("2024");
    393.             oldDto.setPosterMonth("10.18");
    394.             oldDto.setPosterDay("14:30 ~ 15:30(周四)");
    395.             oldDto.setPosterAddress("电信楼101讲学厅");
    396.             oldDto.setPosterSchool("中山大学（东校园）");
    397.             oldDto.setPosterMainSpeaker("欧阳上官");
    398.         } else {
    399.             oldDto.setPosterTopic("逸仙生命讲坛人第五十九讲");
    400.             oldDto.setPosterTitle("时空相分离调控的职务细胞信号转导");
    401.             oldDto.setPosterYear("2024");
    402.             oldDto.setPosterMonth("1.23");
    403.             oldDto.setPosterDay("20:12 ~ 11:00  周五");
    404.             oldDto.setPosterAddress("中山大学（东校园）-电信楼101讲学厅");
    405.             oldDto.setPosterMainSpeaker("欧阳上官");
    406.             oldDto.setPosterPeopleDetail("我啥事打卡机大街上的情况为其较为气温气温其味无穷我的撒登记卡水电气网红，诶打算近期我后端数据啊按地区为背景墙网格袋安山东划算的挥洒的企鹅企鹅群。");
    407.             oldDto.setMainPeople("李剑锋");
    408.         }
    409.         return oldDto;
    410.     }

  • 相关阅读:
    java基于springboot+vue+elementui的饭店点菜外卖平台 前后端分离
    解决跨域的三种方案
    Python和Java哪个更好找工作？
    024. 解压报文[200 分]
    Leetcode137. 某一个数字出现一次,其余数字出现3次
    【剑指 Offer 66. 构建乘积数组】（很巧妙）
    JVM详解【三】JVM的内存结构
    行车记录仪E-mark认证要如何办理？
    Spring Security OAuth实现GitHub快捷登录
    一文读懂！异常检测全攻略！从统计方法到机器学习 ⛵
  • 原文地址：https://blog.csdn.net/XikYu/article/details/138194564