struts2 using kindeditor upload pictures (including jmagic compressed images)

Project uses a kindeditor3.4

UploadContentImgAction

 @SuppressWarnings("serial")
 @ParentPackage("control-center")
 public class UploadContentImgAction extends BaseAction {
         private File up;
         private String upFileName;
         private String upContentType;
         private String fileDir = "uploads/articleContentImg";
         private String imgTitle;
         private String align;
         private int imgWidth;
         private int imgHeight;
 
         /**
          * kindeditor Picture upload
          * @return
          * @throws Exception
          */
         @Action("kindeditorImgUpload")
         public String kindeditorImgUpload() throws Exception {
                 // You can only upload pictures
                 try {
                         if(!validatePostfix(upFileName)) {
                                 return "error";
                         }
                         User user = (User)getSession().get("user");
                         String fileRealDir = getServletContext().getRealPath(fileDir);
                         File file = up;
                         String fileRealName = createfilename(user.getUserId());
                         String fileName = fileRealName + upFileName.substring(upFileName.lastIndexOf(".")).toLowerCase();
                         File newFile = new File(fileRealDir, fileName);
                         FileUtils.copyFile(file, newFile);
                         // Compress pictures
                         ImageUtil.resize(newFile.getPath(), newFile.getPath(), 500);
                         String id = "contentId";
                         String url = "/" + fileDir + "/" + fileName;
                         String border = "0";
 
                         String result = "<script type='text/javascript'>parent.KE.plugin['image'].insert('" + id + "','" + url + "','" + imgTitle + "','" + imgHeight + "','" + imgHeight + "','" + border + "','" + align + "');</script>";
 
                         getHttpServletResponse().getWriter().write(result);
                 } catch (RuntimeException e) {
                         // TODO Auto-generated catch block
                         e.printStackTrace();
                 }
                 return null;
         }
         /**
          *  The file name generation  :  The current time  +  Random number  +  User ID
          */
         private String createfilename(int userId) {
                 StringBuilder result = new StringBuilder();
                 //  Get the local time of the current
                 String now = DateUtil.getLongStrFromDate(new Date());
                 //  In 1000W of randomly generated numbers
                 int rand = new Random().nextInt(9999999);
                 //  Get rid of  -  Get rid of  :  Get rid of the whitespace  , Returns the
                 result.append(now.replace("-", "").replace(":", "").replace(" ", "")).append("_").append(rand).append("_").append(userId);
                 return result.toString();
         }
         /**
          *  Verify that the suffix name should obtain from the configuration file
          */
         public boolean validatePostfix(String filename) {
                 //  Defines the type of the uploaded file
                 List<String> fileTypes = new ArrayList<String>();
 
                 //  Picture
                 fileTypes.add("jpg");
                 fileTypes.add("jpeg");
                 fileTypes.add("bmp");
                 fileTypes.add("gif");
                 fileTypes.add("png");
 
                 //  Get file mantissa and lowercase
                 String postfix = filename.substring(filename.lastIndexOf(".") + 1).toLowerCase();
                 return fileTypes.contains(postfix) ? true : false;
         }
         public File getUp() {
                 return up;
         }
 
         public void setUp(File up) {
                 this.up = up;
         }
 
         public String getUpFileName() {
                 return upFileName;
         }
 
         public void setUpFileName(String upFileName) {
                 this.upFileName = upFileName;
         }
 
         public String getUpContentType() {
                 return upContentType;
         }
 
         public void setUpContentType(String upContentType) {
                 this.upContentType = upContentType;
         }
 
         public String getImgTitle() {
                 return imgTitle;
         }
 
         public void setImgTitle(String imgTitle) {
                 this.imgTitle = imgTitle;
         }
 
         public int getImgWidth() {
                 return imgWidth;
         }
 
         public void setImgWidth(int imgWidth) {
                 this.imgWidth = imgWidth;
         }
 
         public int getImgHeight() {
                 return imgHeight;
         }
 
         public void setImgHeight(int imgHeight) {
                 this.imgHeight = imgHeight;
         }
 
         public String getAlign() {
                 return align;
         }
 
         public void setAlign(String align) {
                 this.align = align;
         }
 }

ImageUitl

 package com.yancheng.myframe.util;
 
 import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Font;
 import java.awt.Graphics2D;
 import java.awt.Image;
 import java.awt.geom.AffineTransform;
 import java.awt.image.AffineTransformOp;
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import javax.imageio.ImageIO;
 import magick.ImageInfo;
 import magick.MagickImage;
 import com.sun.image.codec.jpeg.JPEGCodec;
 import com.sun.image.codec.jpeg.JPEGImageEncoder;
 
 /**
  * @author
  *
  */
 public class ImageUtil {
 
         public final static int PHOTO_RATIO = 800; // Scaling the picture coefficient
         static{
                 System.setProperty("jmagick.systemclassloader", "no");
         }
         /**
          *  Picture watermark
          *
          * @param pressImg  Watermark picture
          * @param targetImg  Target picture
          * @param x  Fixed value defaults in the Middle
          * @param y  Fixed value defaults in the Middle
          * @param alpha  Transparency
          */
         public final static void pressImage(String pressImg, String targetImg,
                         int x, int y, float alpha) {
                 try {
                         File img = new File(targetImg);
                         Image src = ImageIO.read(img);
                         int wideth = src.getWidth(null);
                         int height = src.getHeight(null);
                         BufferedImage image = new BufferedImage(wideth, height,
                                         BufferedImage.TYPE_INT_RGB);
                         Graphics2D g = image.createGraphics();
                         g.drawImage(src, 0, 0, wideth, height, null);
                         //  The watermark file
                         Image src_biao = ImageIO.read(new File(pressImg));
                         int wideth_biao = src_biao.getWidth(null);
                         int height_biao = src_biao.getHeight(null);
                         g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP,
                                         alpha));
                         g.drawImage(src_biao, (wideth - wideth_biao) / 2,
                                         (height - height_biao) / 2, wideth_biao, height_biao, null);
                         //  At the end of the watermark file
                         g.dispose();
                         ImageIO.write((BufferedImage) image, "jpg", img);
                 } catch (Exception e) {
                         e.printStackTrace();
                 }
         }
 
         /**
          *  Text watermark
          *
          * @param pressText  Watermark text
          * @param targetImg  Target picture
          * @param fontName  Font name
          * @param fontStyle  Font style
          * @param color  Font color
          * @param fontSize  Font size
          * @param x  Correction value
          * @param y  Correction value
          * @param alpha  Transparency
          */
         public static void pressText(String pressText, String targetImg, String fontName, int fontStyle, Color color, int fontSize, int x,
                         int y, float alpha) {
                 try {
                         File img = new File(targetImg);
                         Image src = ImageIO.read(img);
                         int width = src.getWidth(null);
                         int height = src.getHeight(null);
                         BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
                         Graphics2D g = image.createGraphics();
                         g.drawImage(src, 0, 0, width, height, null);
                         g.setColor(color);
                         g.setFont(new Font(fontName, fontStyle, fontSize));
                         g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, alpha));
                         g.drawString(pressText, (width - (getLength(pressText) * fontSize)) / 2 + x, (height - fontSize) / 2 + y);
                         g.dispose();
                         ImageIO.write((BufferedImage) image, "jpg", img);
                 } catch (Exception e) {
                         e.printStackTrace();
                 }
         }
 
         /**
          *  Zoom effects poor ps  : Graphics The following are the AffineTransform under
          *  Zoom is for  " Graphics  " Instead of  " Image  " So after the picture is not clear
          * @param filePath  The path to the picture
          * @param height  Height
          * @param width  Width
          * @param bb  The ratio is not environmentally friendly farming is required when the
          */
         public static void resizeImgcale(String filePath, int height, int width, boolean bb) {
                 try {
                         double ratio = 0.0; //  Scaling
                         File f = new File(filePath);
                         BufferedImage bi = ImageIO.read(f);
                         Image itemp = bi.getScaledInstance(width, height, bi.SCALE_SMOOTH);
                         //  Calculate the ratio
                         if ((bi.getHeight() > height) || (bi.getWidth() > width)) {
                                 if (bi.getHeight() > bi.getWidth()) {
                                         ratio = (new Integer(height)).doubleValue() / bi.getHeight();
                                 } else {
                                         ratio = (new Integer(width)).doubleValue() / bi.getWidth();
                                 }
                                 AffineTransformOp op = new AffineTransformOp(AffineTransform.getScaleInstance(ratio, ratio), null);
                                 itemp = op.filter(bi, null);
                         }
                         if (bb) {
                                 BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
                                 Graphics2D g = image.createGraphics();
                                 g.setColor(Color.white);
                                 g.fillRect(0, 0, width, height);
                                 if (width == itemp.getWidth(null))
                                         g.drawImage(itemp, 0, (height - itemp.getHeight(null)) / 2,
                                                         itemp.getWidth(null), itemp.getHeight(null),
                                                         Color.white, null);
                                 else
                                         g.drawImage(itemp, (width - itemp.getWidth(null)) / 2, 0,
                                                         itemp.getWidth(null), itemp.getHeight(null),
                                                         Color.white, null);
                                 g.dispose();
                                 itemp = image;
                         }
                         ImageIO.write((BufferedImage) itemp, "jpg", f);
                 } catch (IOException e) {
                         e.printStackTrace();
                 }
         }
 
         /**
          *  Calculates the length of the word
          *
          * @param text
          * @return
          */
         public static int getLength(String text) {
                 int length = 0;
                 for (int i = 0; i < text.length(); i++) {
                         if (new String(text.charAt(i) + "").getBytes().length > 1) {
                                 length += 2;
                         } else {
                                 length += 1;
                         }
                 }
                 return length / 2;
         }
 
         /**
          *  Compress pictures
          *
          * @param imgsrc  Source file
          * @param imgdist  The target file
          * @param widthdist  Width
          * @param heightdist  High
          */
         public static void resizeImg(String imgsrc, String imgdist, int widthdist, int heightdist) {
                 try {
                         File srcfile = new File(imgsrc);
                         if (!srcfile.exists()) {
                                 return;
                         }
                         Image src = javax.imageio.ImageIO.read(srcfile);
                         BufferedImage tag = new BufferedImage(widthdist, heightdist, BufferedImage.TYPE_INT_RGB);
                         /*
                          * SCALE_SMOOTH Smooth SCALE: dimensions  _AREA_AVERAGING : Scale area average SCALE  _FAST : Scale fast
                          * SCALE_REPLICATE :-Scale replication
                          */
                         tag.getGraphics().drawImage(src.getScaledInstance(widthdist, heightdist, Image.SCALE_SMOOTH), 0, 0, null);
                         FileOutputStream out = new FileOutputStream(imgdist);
                         JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
                         encoder.encode(tag);
                         out.close();
                 } catch (IOException ex) {
                         ex.printStackTrace();
                 }
         }
 
         /**
          *  Picture compression
          * @param picFrom
          * @param picTo
          * @param widthdist
          * @param heightdist
          */
         public static void resize(String picFrom, String picTo, int widthdist, int heightdist) {
                 try {
                         ImageInfo info = new ImageInfo(picFrom);
                         MagickImage image = new MagickImage(new ImageInfo(picFrom));
                         MagickImage scaled = image.scaleImage(widthdist, heightdist);//  The small size of the picture file  .
                         scaled.setFileName(picTo);
                         scaled.writeImage(info);
                 } catch (Exception ex) {
                         ex.printStackTrace();
                 }
         }
 
         public static void resize(String picFrom, String picTo, int ratio) throws Exception {
                 BufferedImage bi = ImageIO.read(new File(picFrom));
                 // The original picture properties
                 int srcWidth = bi.getWidth();
                 int srcHeight = bi.getHeight();
                 // Generate picture properties
                 int newWidth = srcWidth;
                 int newHeight = srcHeight;
                 // If you exceed the maximum width or height is compressed
                 if (srcWidth > ratio || newHeight > ratio) {
                         // Generate picture width  , height Calculation
                         if (srcWidth >= srcHeight) {
                                 if (srcWidth < ratio) {
                                         return;
                                 }
                                 newWidth = ratio;
                                 newHeight = (int)(ratio * srcHeight / srcWidth);
                         } else {
                                 if (srcHeight < ratio) {
                                         return;
                                 }
                                 newHeight = ratio;
                                 newWidth = (int)(ratio * srcWidth / srcHeight);
                         }
                 }
                 resize(picFrom, picTo, newWidth, newHeight);
         }
 
         public static void resize(String picFrom, String picTo) throws Exception {
                 resize(picFrom, picTo, PHOTO_RATIO);
         }
 
         public static void main(String[] args) throws Exception {
         //      resizeImg("d:/411766.jpg", "d:/411766_1.jpg", 800, 600);
         //      resize("d:/test_4.jpg", "d:/test_4_2.jpg", 800);
                 pressText(" Joy and the damned  ", "d:/411766.jpg", " Simplified Chinese  ", Font.ITALIC, Color.black, 90, 40, 80, 0.5f);
         }
 
 }