紫玉坏小子

导航

在指定的背景图上按指定位置放置文字和图片

 

 

在指定的背景图上按指定位置放置文字和图片

  • 在指定的背景图中放置指定的文字

从网上查询资料----->得到的结果

  • Springboot 图片添加文字水印
  • 项目要求给每个考生制作证书。这里我们有每个公司需要的背景图片模板,而我现在要做的就是把每个考生的考试信息和个人信息,以水印的形式添加到图片的指定位置。(现在这个灵活性不高)下面就直接上代码。

    • 首先我这边先写了一个工具类waterMarkUtils 。在这个工具类里面主要设置每个水印的位置以及字体还有存放位置。(我这边因为要上传到服务器,所以就稍微处理了一下,还有我这个可以添加多个水印,图片的来源是网络路径)代码如下:

    • import javax.imageio.ImageIO;
      import java.awt.*;
      import java.awt.image.BufferedImage;
      import java.io.*;
      import java.math.BigDecimal;
      import java.net.HttpURLConnection;
      import java.net.URL;

      public class WaterMarkUtils {
        /**
         * @param srcImgPath 源图片路径
         * @param tarImgPath 保存的图片路径
         * @param waterMarkContent 水印内容
         * @param markContentColor 水印颜色
         * @param font 水印字体
         * @param workerNames
         */
        public static Object addWaterMark(
                        String srcImgPath,
                        String tarImgPath,
                        String waterMarkContent,
                        String workerNames,
                        String workerCardNums,
                        String allStaffOrgNames,
                        BigDecimal studentScores,
                        String certNums,
                        String trainCredentialNames,
                        String templateContents,
                        Color markContentColor,
                        Font font) {
            try {
                //new一个url对象
                URL url = new URL(srcImgPath);
                //打开链接
                HttpURLConnection  conn = (HttpURLConnection)url.openConnection();
                //设置请求方式
                /*conn.setRequestMethod("GET");*/
                //超时相应时间为5秒
                conn.setConnectTimeout(5*1000);
                //通过输入流获取图片数据
                InputStream inputStream = null;
                try {
                    inputStream = conn.getInputStream();
                }catch (Exception e){
                    e.printStackTrace();
                }
                //文件转化为图片
                Image srcImg = null;
                try {
                    srcImg = ImageIO.read(inputStream);
                }catch (Exception e){
                    e.printStackTrace();
                }
                //获取图片的宽
                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);
                //设置时间水印的坐标
                int x = (int) (
                     srcImgWidth - 1.64*getWatermarkLength(waterMarkContent, g));
                int y = (int) (
                     srcImgHeight - 1.15*getWatermarkLength(waterMarkContent, g));
                int x2 = 0;
                int y2 = 0;
                //设置姓名水印坐标
                if (workerNames.length() == 3){
                     x2 = (int) (srcImgWidth - 7.4*getWatermarkLength(workerNames,g));
                     y2 = (int) (
                         srcImgHeight - 7.27*getWatermarkLength(workerNames,g));
                }else if (workerNames.length() == 2){
                     x2 = (int) (srcImgWidth - 11*getWatermarkLength(workerNames,g));
                     y2 = (int) (srcImgHeight - 10.9*getWatermarkLength(workerNames,g));
                }else if (workerNames.length() == 4){
                    x2 = (int) (srcImgWidth - 5.9*getWatermarkLength(workerNames,g));
                    y2 = (int) (srcImgHeight - 5.45*getWatermarkLength(workerNames,g));
                }
                int x3 =0;
                int y3 =0;
                if (workerCardNums.length() == 18){
                    //设置身份证号水印坐标
                    x3 = (int) (
                        srcImgWidth - 1.6*getWatermarkLength(workerCardNums,g));
                    y3 = (int) (
                        srcImgHeight - 0.4*getWatermarkLength(workerCardNums,g));
                }else if (workerCardNums.length() == 17){
                    x3 = (int) (
                        srcImgWidth - 1.7*getWatermarkLength(workerCardNums,g));
                    y3 = (int) (
                        srcImgHeight - 0.42*getWatermarkLength(workerCardNums,g));
                }else if (workerCardNums.length() == 16){
                    x3 = (int) (
                        srcImgWidth - 1.8*getWatermarkLength(workerCardNums,g));
                    y3 = (int) (
                        srcImgHeight - 0.45*getWatermarkLength(workerCardNums,g));
                }
                //设置组织名称水印坐标
                int x4 = srcImgWidth - 2*getWatermarkLength(allStaffOrgNames,g);
                int y4 = srcImgHeight - 3*getWatermarkLength(allStaffOrgNames,g);
                int x5 = 0;
                int y5 = 0;
                if (studentScores.longValue() >= 100){
                    //设置分数水印坐标
                    x5 = (int) (
               srcImgWidth - 11.8*getWatermarkLength(String.valueOf(studentScores),g));
                    y5 = (int) (
               srcImgHeight - 9.7*getWatermarkLength(String.valueOf(studentScores),g));
                }else if (studentScores.longValue() <10 && studentScores.longValue()>=                  0){
                    //设置分数水印坐标
                    x5 = (int) (
                srcImgWidth - 35*getWatermarkLength(String.valueOf(studentScores),g));
                    y5 = (int) (
             srcImgHeight - 28.99*getWatermarkLength(String.valueOf(studentScores),g));
                }else if (studentScores.longValue() <= 99 && studentScores.longValue()> 10){
                    //设置分数水印坐标
                    x5 = (int) (
             srcImgWidth - 17.4*getWatermarkLength(String.valueOf(studentScores),g));
                    y5 = (int) (
             srcImgHeight - 14.5*getWatermarkLength(String.valueOf(studentScores),g));
                }

                //设置证书编号水印坐标
                int x6 = 0;
                int y6 = 0;
                if (certNums.length() == 15){
                    x6 = (int) (srcImgWidth - 2.09*getWatermarkLength(certNums,g));
                    y6 = (int) (srcImgHeight - 4.14*getWatermarkLength(certNums,g));
                }
                //设置证书名称水印坐标
                int x7 = srcImgWidth - 3*getWatermarkLength(trainCredentialNames,g);
                int y7 = srcImgHeight - 2*getWatermarkLength(trainCredentialNames,g);
                //设置模板内容水印坐标
                int x8 = srcImgWidth - 1*getWatermarkLength(templateContents,g);
                int y8 = srcImgHeight - 1*getWatermarkLength(templateContents,g);

                //画出水印
                g.drawString(waterMarkContent,x,y);
                g.drawString(workerNames,x2,y2);
                g.drawString(workerCardNums,x3,y3);
               /* g.drawString(allStaffOrgNames,x4,y4);*/
                g.drawString(String.valueOf(studentScores),x5,y5);
                g.drawString(certNums,x6,y6);
                /*g.drawString(trainCredentialNames,x7,y7);
                g.drawString(templateContents,x8,y8);*/
                g.dispose();
                // 输出图片
      //           FileOutputStream outImgStream = new FileOutputStream(tarImgPath);
      //           ImageIO.write(bufImg, "jpeg", outImgStream);
                System.out.println("添加水印完成");
                return bufImg;
            } catch (Exception e) {
                // TODO: handle exception
            }
            return null;
        }

        private byte[] readInputStream(InputStream inputStream) throws IOException {
            ByteArrayOutputStream outStream = new ByteArrayOutputStream();
            //创建一个Buffer字符串
            byte[] buffer = new byte[1024];
            //每次读取的字符串长度,如果为-1,代表全部读取完毕
            int len = 0;
            //使用一个输入流从buffer里把数据读取出来
            while( (len=inputStream.read(buffer)) != -1 ){
                //用输出流往buffer里写入数据,中间参数代表从哪个位置开始读,len代表读取的长度
                outStream.write(buffer, 0, len);
            }
            //关闭输入流
            inputStream.close();
            //把outStream里的数据写入内存
            return outStream.toByteArray();
        }

        public static int getWatermarkLength(String waterMarkContent, Graphics2D g) {
            return       g.getFontMetrics(g.getFont()).charsWidth(waterMarkContent.toCharArray(), 0, waterMarkContent.length());
        }
      }
    • 然后就是自己写查询的代码了,我这里是直接在serviceImpl 实现类里面调用的这个工具类 代码如下:

    • service层接口:
           Map<String,Object> getAllStaffTrainWorker(JSONObject jsonParam)
    • serviceImpl实现类:
           /**
          * 获取证书需要的字段
          * @return
          */
         @Override
         public Map<String,Object> getAllStaffTrainWorker(JSONObject jsonParam) {
             String allStaffWorkerId = jsonParam.getString("allStaffWorkerIds");
             if (null == allStaffWorkerId){
                 errLog("getAllStaffTrainWorker", ErrorCodeMsg.PARAM_ERROR.getMessage(), "员工id不存在");
                 throw new AttemptException(ErrorCodeMsg.PARAM_ERROR,"员工id不存在");
            }
             //员工表查询出员工的基本信息
             Example example = new Example(AllStaffTrainWorker.class);
             Example.Criteria criteria = example.createCriteria();
             criteria.andEqualTo("isDeleted", CmnConstants.IS_DELETED_NO);
             criteria.andEqualTo("isEnabled", CmnConstants.IS_ENABLED_YES);
             String [] allStaffWorkerArry = allStaffWorkerId.split(",");
             List<Long> allStaffWorkerIds = new ArrayList<>();
             for (String allStaffWorkerIdss :allStaffWorkerArry){
                 allStaffWorkerIds.add(Long.valueOf(allStaffWorkerIdss));
            }
             criteria.andIn("allStaffWorkerId",allStaffWorkerIds);
             List<AllStaffTrainWorker> allStaffTrainWorkerList = this.allStaffTrainWorkerMapper.selectByExample(example);
             //姓名
             String workerName = null;
             //身份证号
             String workerCardNum = null;
             //组织名称
             String allStaffOrgName = null;
             //学员得分
             BigDecimal studentScore = null;
             //证书编号
             String certNum = null;
             //证书名称
             String trainCredentialName = null;
             //获取模板内容
             String templateContent = null;
             //获取背景图片路径
             String imgUrl =null;
             if (null != allStaffTrainWorkerList){
                 for (AllStaffTrainWorker allStaffTrainWorker1 : allStaffTrainWorkerList){
                     workerName= allStaffTrainWorker1.getWorkerName();
                     workerCardNum = allStaffTrainWorker1.getWorkerCardNum();
                     allStaffOrgName = allStaffTrainWorker1.getAllStaffOrgName();
                }
                 //考试表获取分数
                 Example example1 = new Example(AllStaffTrainWorkerExam.class);
                 Example.Criteria criteria1 = example1.createCriteria();
                 criteria1.andEqualTo("isDeleted", CmnConstants.IS_DELETED_NO);
                 criteria1.andEqualTo("isEnabled", CmnConstants.IS_ENABLED_YES);
                 criteria1.andEqualTo("allStaffWorkerId",allStaffWorkerId);
                 List<AllStaffTrainWorkerExam> allStaffTrainWorkerExamList = this.allStaffTrainWorkerExamMapper.selectByExample(example1);
                 for (AllStaffTrainWorkerExam allStaffTrainWorkerExam : allStaffTrainWorkerExamList){
                     studentScore =  allStaffTrainWorkerExam.getStudentScore();
                }
                 //证书表得到证书编号
                 Example example2 = new Example(AllStaffTrainWorkerCert.class);
                 Example.Criteria criteria2 = example2.createCriteria();
                 criteria2.andEqualTo("isDeleted", CmnConstants.IS_DELETED_NO);
                 criteria2.andEqualTo("isEnabled", CmnConstants.IS_ENABLED_YES);
                 criteria2.andEqualTo("allStaffWorkerId",allStaffWorkerId);
                 List<AllStaffTrainWorkerCert> allStaffTrainWorkerCertList = this.allStaffTrainWorkerCertMapper.selectByExample(example2);
                 Long allStaffTrainCertId = null;
                 for (AllStaffTrainWorkerCert allStaffTrainWorkerCert : allStaffTrainWorkerCertList){
                     certNum =  allStaffTrainWorkerCert.getCertNum();
                     allStaffTrainCertId = allStaffTrainWorkerCert.getAllStaffTrainCertId();
                }
                 //配置证书表获取证书名称
                 Example example3= new Example(AllStaffTrainCert.class);
                 Example.Criteria criteria3 = example3.createCriteria();
                 criteria3.andEqualTo("isDeleted", CmnConstants.IS_DELETED_NO);
                 criteria3.andEqualTo("isEnabled", CmnConstants.IS_ENABLED_YES);
                 criteria3.andEqualTo("allStaffTrainCertId",allStaffTrainCertId);
                 List<AllStaffTrainCert> allStaffTrainCertList = this.allStaffTrainCertMapper.selectByExample(example3);
                 //模板id
                 Long allStaffTrainTemplateId = null;
                 //图片id
                 Long allStaffTrainImgId = null;
                 for (AllStaffTrainCert allStaffTrainCert : allStaffTrainCertList){
                     trainCredentialName = allStaffTrainCert.getTrainCredentialName();
                     allStaffTrainTemplateId = allStaffTrainCert.getAllStaffTrainTemplateId();
                     allStaffTrainImgId = allStaffTrainCert.getAllStaffTrainImgId();
                }
                 Example example4 = new Example(AllStaffTrainCertTemplate.class);
                 Example.Criteria criteria4 = example4.createCriteria();
                 criteria4.andEqualTo("isDeleted", CmnConstants.IS_DELETED_NO);
                 criteria4.andEqualTo("isEnabled", CmnConstants.IS_ENABLED_YES);
                 criteria4.andEqualTo("allStaffTrainTemplateId",allStaffTrainTemplateId);
                 AllStaffTrainCertTemplate allStaffTrainCertTemplate = this.allStaffTrainCertTemplateMapper.selectOneByExample(example4);
                 //获取模板内容
                  templateContent = allStaffTrainCertTemplate.getTemplateContent();
                 Example example5 = new Example(AllStaffTrainCertImg.class);
                 Example.Criteria criteria5 = example5.createCriteria();
                 criteria5.andEqualTo("isDeleted", CmnConstants.IS_DELETED_NO);
                 criteria5.andEqualTo("isEnabled", CmnConstants.IS_ENABLED_YES);
                 criteria5.andEqualTo("allStaffTrainImgId",allStaffTrainImgId);
                 AllStaffTrainCertImg allStaffTrainCertImg = this.allStaffTrainCertImgMapper.selectOneByExample(example5);
                 //获取背景图片路径
                  imgUrl = allStaffTrainCertImg.getImgUrl();
            }
             ClassPathResource classPathResource = new ClassPathResource("fonts/msyh.ttc");
             InputStream inputStream = null;
             try {
                inputStream = classPathResource.getInputStream();
            }catch (Exception e){
                 e.getMessage();
            }
             Font dynamicFont = null;
             try {
                 dynamicFont = Font.createFont(Font.TRUETYPE_FONT, inputStream);
            }catch (Exception e){
                 e.printStackTrace();
            }
             Font font = dynamicFont.deriveFont(Font.PLAIN, 28); //水印字体 方法3
             //水印字体
             /*Font font = new Font("微软雅黑", Font.PLAIN, 28);*/
             //源图片地址
             String srcImgPath="http://"+imgUrl;
             //待存储的地址
             String tarImgPath = "F:/证书.jpeg";
             //格式化时间
             SimpleDateFormat f=new SimpleDateFormat("yyyy     MM     dd");
             String format = f.format(new Date());
             //时间
             String waterMarkContent=format;
             //姓名
             String workerNames = workerName;
             //身份证号
             String workerCardNums = workerCardNum;
             //组织名称
             String allStaffOrgNames = allStaffOrgName;
             //学员得分
             BigDecimal studentScores = studentScore;
             //证书编号
             String certNums =certNum;
             //证书名称
             String trainCredentialNames = trainCredentialName;
             //获取模板内容
             String templateContents = templateContent;

             //水印图片色彩以及透明度
             Color color=new Color(79 ,79 ,79);
             BufferedImage bufferedImage = (BufferedImage) WaterMarkUtils.addWaterMark(srcImgPath, tarImgPath, waterMarkContent, workerNames, workerCardNums, allStaffOrgNames, studentScores, certNums, trainCredentialNames, templateContents, color, font);
             String sessionToke =jsonParam.getString("sessionToke");
             String attname = "证书"+".jpeg";
             String url = null;
             try {
                 byte[] jpegs = imageToBytes(bufferedImage, "jpeg");
                 url = FastDFSUtils.getDoUpload(sessionToke,attname,jpegs);
            }catch (Exception e){
                 errLog("getDownloadAllStaffWorkers",ErrorCodeMsg.UNKNOWN_ERROR.getMessage(),e.getMessage());
                 throw new AttemptException(ErrorCodeMsg.UNKNOWN_ERROR,e.getMessage());
            }
             Map<String, Object> resultMap = getFastDFSFileInfoMap(url,attname);
             return resultMap;
        }

         public  byte[] imageToBytes(BufferedImage bImage, String format) {
             ByteArrayOutputStream out = new ByteArrayOutputStream();
             try {
                 ImageIO.write(bImage, format, out);
            } catch (IOException e) {
                 e.printStackTrace();
            }
             return out.toByteArray();
        }

         /**
          * 返回给前端下载地址
          *
          * @param url
          * @param attname
          * @return
          */
         private Map<String, Object> getFastDFSFileInfoMap(String url, String attname) {
             String filePath = null;
             if (StringUtils.isNotEmpty(url)) {
                 JSONObject jsonObject = JSONObject.parseObject(url);
                 String data = jsonObject.getString("data");
                 JSONObject dataObject = JSONObject.parseObject(data);
                 filePath = dataObject.getString("filePath");
                 if (StringUtils.isEmpty(filePath)) {
                     errLog("getFastDFSFileInfoMap", ErrorCodeMsg.UNKNOWN_ERROR.getMessage(), "获取文件服务下载地址为空");
                     throw new AttemptException(ErrorCodeMsg.UNKNOWN_ERROR, "获取文件服务下载地址为空");
                }
            }
             Map<String, Object> map = new HashMap<>(32);
             map.put("url",fileServer+"/"+filePath);
             map.put("attname", attname);
             return map;
        }
    • controller层代码
         /**
          * 证书需要的内容
          * @return
          */
         @PostMapping("/getAllStaffTrainWorker")
         public ResponseStruct getAllStaffTrainWorker(@RequestBody JSONObject jsonParam){
             return ResponseStruct.success(this.allStaffTrainWorkerCertInterface.getAllStaffTrainWorker(jsonParam));
        }
    • 总结: 这里面的坑: 1.图片是我们这边上传到服务器的所以数据库存放的的 url 而且输入到浏览器可以直接下载的。所以读取文件url的时候,我进行了了处理 具体代码就在工具类最上面 2.每个水印因为文字的字体和大小变动,位置也会变动 3.刚一开始文字字体用的Windows自带的字体,上传到服务器之后,因为服务器没有字体。要么下载一个要么想我这样 把字体包放到项目根目录然后再用流方式获取。 4.字体包位置

根据自己的项目写的代码(证书的添加)
  • 工具类 (添加水印的方法)

    package com.shy.lhs.hsmy.common.constant;

    import com.sen.common.web.controller.BaseApi;
    import com.shy.lhs.hsmy.common.oss.utils.OssFileUtils;
    import org.apache.http.entity.ContentType;
    import org.springframework.mock.web.MockMultipartFile;
    import org.springframework.web.multipart.MultipartFile;

    import javax.imageio.ImageIO;
    import java.awt.*;
    import java.awt.image.BufferedImage;
    import java.io.*;
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.text.SimpleDateFormat;
    import java.util.Date;

    /**
    * 功能描述:
    * 〈考级证书打印方法〉
    *
    * @author : hxz
    * @date : 2021/1/4 14:02
    */
    public class WaterMarkUtils extends BaseApi {

       /**
        * 功能描述:
        * 〈给图片添加文字水印〉
        *
        * @param name         3:考级人姓名
        * @param alphabet:姓名拼音
        * @param sex:性别
        * @param o
        * @return : java.lang.Object
        * @author : hxz
        * @date : 2021/1/4 14:05
        */
       public String addWaterMark(
               String name, String alphabet, String sex, String nationality,
               String nation, Date birthday, String professionalName, String professionalItemName,
               String levelName, String no, String avatar,
               Object o) throws Exception {
           // 固定的背景图
           String SRCIMGPATH = "************";
           //设置返回图片的路径
           String BACKIMG = null;
           try {
               //new一个url对象(连接背景图)
               URL url = new URL(SRCIMGPATH);
               //打开链接
               HttpURLConnection conn = (HttpURLConnection) url.openConnection();
               //超时相应时间为5秒
               conn.setConnectTimeout(5 * 1000);
               //通过输入流获取图片数据
               InputStream inputStream = null;
               inputStream = conn.getInputStream();
               //文件转化为图片
               Image srcImg = null;
               srcImg = ImageIO.read(inputStream);
               //获取图片的宽
               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(Color.black);
               Font font = new Font("宋体", Font.TRUETYPE_FONT, 18);
               g.setFont(font);
               // System.out.println("图片宽:" + srcImgWidth + "图片高:" + srcImgHeight + "xx:" + getWatermarkLength(sex, g));
               //设置姓名水印的坐标
               if (null != name) {
                   int x = (int) (485);
                   int y = (int) (380);
                   g.drawString(name, x, y);
              }
               //设置拼音姓名的坐标
               if (null != alphabet) {
                   int x1 = (int) (500);
                   int y1 = (int) (415);
                   g.drawString(alphabet, x1, y1);
              }
               //设置性别的坐标
               String Psex = null;
               if (null != sex) {
                   if (sex.equals("1")) {
                       sex = "男";
                       Psex = "MAN";
                  } else {
                       sex = "女";
                       Psex = "WOMAN";
                  }
                   int x2 = (int) (486);
                   int y2 = (int) (446);
                   //设置英语性别坐标
                   int x3 = (int) (486);
                   int y3 = (int) (480);
                   g.drawString(sex, x2, y2);
                   g.drawString(Psex, x3, y3);
              }
               if (null != nationality) {
                   //设置国籍坐标
                   int x4 = (int) (486);
                   int y4 = (int) (512);
                   //设置国籍英语
                   int x5 = (int) (580);
                   int y5 = (int) (545);
                   g.drawString(nationality, x4, y4);
                   g.drawString("CN", x5, y5);
              }
               //设置民族
               if (null != nation) {
                   int x6 = (int) (486);
                   int y6 = (int) (578);
                   //设置民族英语
                   int x7 = (int) (520);
                   int y7 = (int) (611);
                   g.drawString(nation, x6, y6);
                   g.drawString("han", x7, y7);
              }
               //设置出生日期
               if (null != birthday) {
                   SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
                   String s = simpleDateFormat.format(birthday);
                   int x8 = (int) (520);
                   int y8 = (int) (644);
                   int x9 = (int) (590);
                   int y9 = (int) (679);
                   g.drawString(s, x8, y8);
                   g.drawString(s, x9, y9);
              }
               if (null != professionalName || null != professionalItemName) {
                   //设置专业
                   int x10 = (int) (520);
                   int y10 = (int) (710);

                   int x11 = (int) (568);
                   int y11 = (int) (740);
                   g.drawString(professionalName + professionalItemName, x10, y10);
                   g.drawString(professionalName + professionalItemName, x11, y11);
              }
               if (null != levelName) {
                   //设置等级
                   int x12 = (int) (480);
                   int y12 = (int) (775);

                   int x13 = (int) (509);
                   int y13 = (int) (805);
                   g.drawString(levelName, x12, y12);
                   g.drawString(levelName, x13, y13);
              }
               //设置发证时间
               SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
               String sdf1 = sdf.format(new Date());
               int x14 = (int) (205);
               int y14 = (int) (628);

               int x15 = (int) (270);
               int y15 = (int) (658);
               //设置起至级
               int x16 = (int) (185);
               int y16 = (int) (688);

               int x17 = (int) (180);
               int y17 = (int) (748);
               //设置证书编号
               if (null != no) {
                   int x18 = (int) (205);
                   int y18 = (int) (778);

                   int x19 = (int) (170);
                   int y19 = (int) (808);

                   g.drawString(no, x18, y18);
                   g.drawString(no, x19, y19);
              }
               //画出图片
               InputStream inputStream1 = null;
               URL url1 = new URL(avatar);
               //打开链接
               HttpURLConnection conn1 = (HttpURLConnection) url1.openConnection();
               //超时相应时间为5秒
               conn.setConnectTimeout(5 * 1000);
               //通过输入流获取图片数据
               inputStream1 = conn1.getInputStream();
               BufferedImage buff = ImageIO.read(inputStream1);
               g.drawImage(buff, 128, 360, 172, 234, null);
               //画出水印
               g.drawString(sdf1, x14, y14);
               g.drawString(sdf1, x15, y15);
               g.drawString("1-10", x16, y16);
               g.drawString("1-10", x17, y17);

               byte[] jpegs = imageToBytes(bufImg, "jpeg");
               InputStream inputStream2 = new ByteArrayInputStream(jpegs);
               MultipartFile file = new MockMultipartFile(ContentType.APPLICATION_OCTET_STREAM.toString(), inputStream2);
               BACKIMG = OssFileUtils.uploadFile(getByte(file), getType(file.getOriginalFilename()));
               inputStream2.close();
               inputStream1.close();
               inputStream.close();
          } catch (Exception e) {
               System.out.println("考级成绩单报错了");
          }
           System.out.println("考级证书图片地址" + BACKIMG);
           return BACKIMG;
      }

       public static byte[] imageToBytes(BufferedImage bImage, String format) {
           ByteArrayOutputStream out = new ByteArrayOutputStream();
           try {
               ImageIO.write(bImage, format, out);
          } catch (IOException e) {
               e.printStackTrace();
          }
           return out.toByteArray();
      }

       public static int getWatermarkLength(String waterMarkContent, Graphics2D g) {
           return g.getFontMetrics(g.getFont()).charsWidth(waterMarkContent.toCharArray(), 0, waterMarkContent.length());
      }

       public static void main(String[] args) throws Exception {
           WaterMarkUtils markUtils = new WaterMarkUtils();
    //       markUtils.addWaterMark("小明","PIN YIN","1","中国","汉族",new Date(),"软笔","书法","三级"
    //       ,"国考","");
      }
    }

 

controller控制层:
    /**
    * 功能描述:
    * 〈考级成绩单〉
    * @param id 1
    * @return : com.sen.common.web.utils.JsonReturn
    * @author : hxz
    * @date : 2020/12/28 14:26
    */
   @GetMapping(value = "info")
   @Auth(userType = AuthUtils.STUDENT)
   public JsonReturn info(Integer id) {
       ExamScoreDto result = examScoreService.findInfoById(AuthUtils.getStudentUser().getId(),id);
       return new JsonReturn(result);
  }
service层:
   ExamScoreDto findInfoById(Integer userId, Integer id);
serviceImpl层:
   @Override
   public ExamScoreDto findInfoById(Integer userId, Integer id) {
       ExamScoreDto examScoreDto = examScoreDao.findInfoByUserIdAndId(userId, id);
       if (null != examScoreDto) {
           OrderStudent orderStudent = orderStudentDao.findById(examScoreDto.getOrderStudentId());
           if (null != orderStudent) {
               examScoreDto.setOrderStudent(orderStudent);
          }
           ExamRoom examRoom = examRoomDao.findById(examScoreDto.getExamRoomId());
           if (null != examRoom) {
               examScoreDto.setExamStartTime(examRoom.getExamStartTime());
               examScoreDto.setExamTime(examRoom.getExamTime());
          }
           Professional professional = professionalDao.findById(examScoreDto.getProfessionalId());
           if (null != professional) {
               examScoreDto.setProfessionalName(professional.getName());
          }
           ProfessionalItem professionalItem = professionalItemDao.findById(examScoreDto.getProfessionalItemId());
           if (null != professionalItem) {
               examScoreDto.setProfessionalItemName(professionalItem.getName());
          }
           SubjectLevel subjectLevel = subjectLevelDao.findById(examScoreDto.getLevelId());
           if (null != subjectLevel) {
               examScoreDto.setLevelName(subjectLevel.getName());
          }
           LevelExam levelExam = levelExamDao.findById(examScoreDto.getLevelExamId());
           if (null != levelExam) {
               examScoreDto.setNo(levelExam.getNo());
          }
           ExamPaper examPaper = examPaperDao.findById(examScoreDto.getExamPaperId());
           if (null != examPaper) {
               examScoreDto.setTitle(examPaper.getTitle());
          }
           //生成证书图片地址
           WaterMarkUtils markUtils = new WaterMarkUtils();
           try {
               String img = markUtils.addWaterMark(orderStudent.getName(), orderStudent.getAlphabet(), orderStudent.getSex(), orderStudent.getNationality(), orderStudent.getNation(), orderStudent.getBirthday(), examScoreDto.getProfessionalName(), examScoreDto.getProfessionalItemName(), examScoreDto.getLevelName(), examScoreDto.getNo(), orderStudent.getAvatar(), "");
               examScoreDto.setBackImg(img);
          } catch (Exception e) {
               System.out.println("生成考级证书错误");
          }
      }
       return examScoreDto;
  }

 

posted on 2021-01-12 10:22  紫玉坏小子  阅读(206)  评论(0编辑  收藏  举报