java生成gif动图验证码

import com.mortals.framework.util.SecurityImage;
import com.mortals.iot.module.common.web.CommonController;
import com.mortals.iot.module.system.base.service.GifSecurityImage;
import com.mortals.iot.module.system.valid.service.ValidCodeService;
import org.apache.commons.io.IOUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.awt.image.BufferedImage;
@RestController
@RequestMapping("securitycode")
public class SecurityCodeController extends CommonController {
    @Autowired
    private ValidCodeService validCodeService;
    @RequestMapping("createCode")
    public void createCode(HttpServletRequest request, HttpServletResponse response) {
    // 获取默认难度和长度的验证码
    String securityCode = "7834";
    // 默认图验
        byte[] content = GifSecurityImage.createGifImage(securityCode);
        doResponseGif(response, content);
    }
    protected void doResponseGif(HttpServletResponse response, byte[] content) {
    try {
        response.setHeader("Pragma", "No-cache");
        response.setHeader("Cache-Control", "No-cache");
        response.setDateHeader("Expires", 0);
        response.setContentType("image/gif");
        IOUtils.write(content, response.getOutputStream());
    } catch (Exception e) {
        log.error("验证码图片传输异常-->" + e.getMessage());
    }
    }
}
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.util.Random;
import javax.imageio.ImageIO;
import lombok.extern.slf4j.Slf4j;
/**
 * gif动态图验证码图片生成器
 *
 */
@Slf4j
public class GifSecurityImage {
    public static BufferedImage createImage(String securityCode) {
        int codeLength = securityCode.length();
        int fSize = 14;
        int fWidth = fSize + 1;
        int width = codeLength * fWidth + 6;
        int height = fSize * 2 + 1;
        BufferedImage image = new BufferedImage(width, height, 1);
        Graphics g = image.createGraphics();
        g.setColor(Color.WHITE);
        g.fillRect(0, 0, width, height);
        g.setColor(Color.LIGHT_GRAY);
        g.setFont(new Font("Arial", 1, height - 2));
        Random rand = new Random();
        // 画点
        g.setColor(Color.LIGHT_GRAY);
        for (int i = 0; i < codeLength * 10; i++) {
            g.setColor(randomColor());
            int x = rand.nextInt(width);
            int y = rand.nextInt(height);
            g.drawOval(x, y, 1, 1);
        }
        for (int i = 0; i < 5; i++) {
            g.setColor(randomColor());
            int x = rand.nextInt(width - 1);
            int y = rand.nextInt(height - 1);
            int xl = rand.nextInt(6) + 1;
            int yl = rand.nextInt(12) + 1;
            g.drawLine(x, y, xl, yl);
        }
        // 写字
        g.setFont(new Font("Georgia", 1, fSize));
        for (int i = 0; i < codeLength; i++) {
            int codeY = height - 8 - rand.nextInt(5);
            int codeX = width / 4 * i + (width / 4 - fSize) / 2;
            g.drawString(String.valueOf(securityCode.charAt(i)), codeX, codeY);
        }
        g.dispose();
        return image;
    }
    public static byte[] createGifImage(String securityCode) {
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        AnimatedGifEncoder gifEncoder = new AnimatedGifEncoder();
        gifEncoder.setRepeat(0);
        gifEncoder.start(outputStream);
        for (int j = 0; j < 4; j++) {
            gifEncoder.setDelay(200); // 设置播放的延迟时间
            gifEncoder.addFrame(createImage(securityCode));
        }
        gifEncoder.finish();
        return outputStream.toByteArray();
    }
    private static Color randomColor() {
        Random random = new Random();
        int r = random.nextInt(256);
        int g = random.nextInt(256);
        int b = random.nextInt(256);
        return new Color(r, g, b);
    }
    public static ByteArrayInputStream getImageAsInputStream(String securityCode) {
        BufferedImage image = createImage(securityCode);
        return convertImageToStream(image);
    }
    private static ByteArrayInputStream convertImageToStream(BufferedImage image) {
        ByteArrayInputStream inputStream = null;
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        try {
            byte[] bts = bos.toByteArray();
            inputStream = new ByteArrayInputStream(bts);
            ImageIO.write(image, "JPG", bos);
        } catch (Exception e) {
            log.debug("转换图片数据流异常-->" + e.getMessage());
        }
        return inputStream;
    }
}
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;  
/**  
 * Class AnimatedGifEncoder - Encodes a GIF file consisting of one or  
 * more frames.  
 * <pre>  
 * Example:  
 *    AnimatedGifEncoder e = new AnimatedGifEncoder();  
 *    e.start(outputFileName);  
 *    e.setDelay(1000);   // 1 frame per sec  
 *    e.addFrame(image1);  
 *    e.addFrame(image2);  
 *    e.finish();  
 * </pre>  
 * No copyright asserted on the source code of this class.  May be used  
 * for any purpose, however, refer to the Unisys LZW patent for restrictions  
 * on use of the associated LZWEncoder class.  Please forward any corrections  
 * to kweiner@fmsware.com.  
 *  
 * @author Kevin Weiner, FM Software  
 * @version 1.03 November 2003  
 *  
 */  
public class AnimatedGifEncoder {  
 protected int width; // image size  
 protected int height;  
 protected Color transparent = null; // transparent color if given  
 protected int transIndex; // transparent index in color table  
 protected int repeat = -1; // no repeat  
 protected int delay = 0; // frame delay (hundredths)  
 protected boolean started = false; // ready to output frames  
 protected OutputStream out;  
 protected BufferedImage image; // current frame  
 protected byte[] pixels; // BGR byte array from frame  
 protected byte[] indexedPixels; // converted frame indexed to palette  
 protected int colorDepth; // number of bit planes  
 protected byte[] colorTab; // RGB palette  
 protected boolean[] usedEntry = new boolean[256]; // active palette entries  
 protected int palSize = 7; // color table size (bits-1)  
 protected int dispose = -1; // disposal code (-1 = use default)  
 protected boolean closeStream = false; // close stream when finished  
 protected boolean firstFrame = true;  
 protected boolean sizeSet = false; // if false, get size from first frame  
 protected int sample = 10; // default sample interval for quantizer  
 /**  
  * Sets the delay time between each frame, or changes it  
  * for subsequent frames (applies to last frame added).  
  *  
  * @param ms int delay time in milliseconds  
  */  
 public void setDelay(int ms) {  
  delay = Math.round(ms / 10.0f);  
 }  
 /**  
  * Sets the GIF frame disposal code for the last added frame  
  * and any subsequent frames.  Default is 0 if no transparent  
  * color has been set, otherwise 2.  
  * @param code int disposal code.  
  */  
 public void setDispose(int code) {  
  if (code >= 0) {  
   dispose = code;  
  }  
 }  
 /**  
  * Sets the number of times the set of GIF frames  
  * should be played.  Default is 1; 0 means play  
  * indefinitely.  Must be invoked before the first  
  * image is added.  
  *  
  * @param iter int number of iterations.  
  * @return  
  */  
 public void setRepeat(int iter) {  
  if (iter >= 0) {  
   repeat = iter;  
  }  
 }  
 /**  
  * Sets the transparent color for the last added frame  
  * and any subsequent frames.  
  * Since all colors are subject to modification  
  * in the quantization process, the color in the final  
  * palette for each frame closest to the given color  
  * becomes the transparent color for that frame.  
  * May be set to null to indicate no transparent color.  
  *  
  * @param c Color to be treated as transparent on display.  
  */  
 public void setTransparent(Color c) {  
  transparent = c;  
 }  
 /**  
  * Adds next GIF frame.  The frame is not written immediately, but is  
  * actually deferred until the next frame is received so that timing  
  * data can be inserted.  Invoking <code>finish()</code> flushes all  
  * frames.  If <code>setSize</code> was not invoked, the size of the  
  * first image is used for all subsequent frames.  
  *  
  * @param im BufferedImage containing frame to write.  
  * @return true if successful.  
  */  
 public boolean addFrame(BufferedImage im) {  
  if ((im == null) || !started) {  
   return false;  
  }  
  boolean ok = true;  
  try {  
   if (!sizeSet) {  
    // use first frame's size  
    setSize(im.getWidth(), im.getHeight());  
   }  
   image = im;  
   getImagePixels(); // convert to correct format if necessary  
   analyzePixels(); // build color table & map pixels  
   if (firstFrame) {  
    writeLSD(); // logical screen descriptior  
    writePalette(); // global color table  
    if (repeat >= 0) {  
     // use NS app extension to indicate reps  
     writeNetscapeExt();  
    }  
   }  
   writeGraphicCtrlExt(); // write graphic control extension  
   writeImageDesc(); // image descriptor  
   if (!firstFrame) {  
    writePalette(); // local color table  
   }  
   writePixels(); // encode and write pixel data  
   firstFrame = false;  
  } catch (IOException e) {  
   ok = false;  
  }  
  return ok;  
 }  
 /**  
  * Flushes any pending data and closes output file.  
  * If writing to an OutputStream, the stream is not  
  * closed.  
  */  
 public boolean finish() {  
  if (!started) return false;  
  boolean ok = true;  
  started = false;  
  try {  
   out.write(0x3b); // gif trailer  
   out.flush();  
   if (closeStream) {  
    out.close();  
   }  
  } catch (IOException e) {  
   ok = false;  
  }  
  // reset for subsequent use  
  transIndex = 0;  
  out = null;  
  image = null;  
  pixels = null;  
  indexedPixels = null;  
  colorTab = null;  
  closeStream = false;  
  firstFrame = true;  
  return ok;  
 }  
 /**  
  * Sets frame rate in frames per second.  Equivalent to  
  * <code>setDelay(1000/fps)</code>.  
  *  
  * @param fps float frame rate (frames per second)  
  */  
 public void setFrameRate(float fps) {  
  if (fps != 0f) {  
   delay = Math.round(100f / fps);  
  }  
 }  
 /**  
  * Sets quality of color quantization (conversion of images  
  * to the maximum 256 colors allowed by the GIF specification).  
  * Lower values (minimum = 1) produce better colors, but slow  
  * processing significantly.  10 is the default, and produces  
  * good color mapping at reasonable speeds.  Values greater  
  * than 20 do not yield significant improvements in speed.  
  *  
  * @param quality int greater than 0.  
  * @return  
  */  
 public void setQuality(int quality) {  
  if (quality < 1) quality = 1;  
  sample = quality;  
 }  
 /**  
  * Sets the GIF frame size.  The default size is the  
  * size of the first frame added if this method is  
  * not invoked.  
  *  
  * @param w int frame width.  
  * @param h int frame width.  
  */  
 public void setSize(int w, int h) {  
  if (started && !firstFrame) return;  
  width = w;  
  height = h;  
  if (width < 1) width = 320;  
  if (height < 1) height = 240;  
  sizeSet = true;  
 }  
 /**  
  * Initiates GIF file creation on the given stream.  The stream  
  * is not closed automatically.  
  *  
  * @param os OutputStream on which GIF images are written.  
  * @return false if initial write failed.  
  */  
 public boolean start(OutputStream os) {  
  if (os == null) return false;  
  boolean ok = true;  
  closeStream = false;  
  out = os;  
  try {  
   writeString("GIF89a"); // header  
  } catch (IOException e) {  
   ok = false;  
  }  
  return started = ok;  
 }  
 /**  
  * Initiates writing of a GIF file with the specified name.  
  *  
  * @param file String containing output file name.  
  * @return false if open or initial write failed.  
  */  
 public boolean start(String file) {  
  boolean ok = true;  
  try {  
   out = new BufferedOutputStream(new FileOutputStream(file));  
   ok = start(out);  
   closeStream = true;  
  } catch (IOException e) {  
   ok = false;  
  }  
  return started = ok;  
 }  
 /**  
  * Analyzes image colors and creates color map.  
  */  
 protected void analyzePixels() {  
  int len = pixels.length;  
  int nPix = len / 3;  
  indexedPixels = new byte[nPix];  
  NeuQuant nq = new NeuQuant(pixels, len, sample);  
  // initialize quantizer  
  colorTab = nq.process(); // create reduced palette  
  // convert map from BGR to RGB  
  for (int i = 0; i < colorTab.length; i += 3) {  
   byte temp = colorTab[i];  
   colorTab[i] = colorTab[i + 2];  
   colorTab[i + 2] = temp;  
   usedEntry[i / 3] = false;  
  }  
  // map image pixels to new palette  
  int k = 0;  
  for (int i = 0; i < nPix; i++) {  
   int index =  
    nq.map(pixels[k++] & 0xff,  
        pixels[k++] & 0xff,  
        pixels[k++] & 0xff);  
   usedEntry[index] = true;  
   indexedPixels[i] = (byte) index;  
  }  
  pixels = null;  
  colorDepth = 8;  
  palSize = 7;  
  // get closest match to transparent color if specified  
  if (transparent != null) {  
   transIndex = findClosest(transparent);  
  }  
 }  
 /**  
  * Returns index of palette color closest to c  
  *  
  */  
 protected int findClosest(Color c) {  
  if (colorTab == null) return -1;  
  int r = c.getRed();  
  int g = c.getGreen();  
  int b = c.getBlue();  
  int minpos = 0;  
  int dmin = 256 * 256 * 256;  
  int len = colorTab.length;  
  for (int i = 0; i < len;) {  
   int dr = r - (colorTab[i++] & 0xff);  
   int dg = g - (colorTab[i++] & 0xff);  
   int db = b - (colorTab[i] & 0xff);  
   int d = dr * dr + dg * dg + db * db;  
   int index = i / 3;  
   if (usedEntry[index] && (d < dmin)) {  
    dmin = d;  
    minpos = index;  
   }  
   i++;  
  }  
  return minpos;  
 }  
 /**  
  * Extracts image pixels into byte array "pixels"  
  */  
 protected void getImagePixels() {  
  int w = image.getWidth();  
  int h = image.getHeight();  
  int type = image.getType();  
  if ((w != width)  
   || (h != height)  
   || (type != BufferedImage.TYPE_3BYTE_BGR)) {  
   // create new image with right size/format  
   BufferedImage temp =  
    new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR);  
   Graphics2D g = temp.createGraphics();  
   g.drawImage(image, 0, 0, null);  
   image = temp;  
  }  
  pixels = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();  
 }  
 /**  
  * Writes Graphic Control Extension  
  */  
 protected void writeGraphicCtrlExt() throws IOException {  
  out.write(0x21); // extension introducer  
  out.write(0xf9); // GCE label  
  out.write(4); // data block size  
  int transp, disp;  
  if (transparent == null) {  
   transp = 0;  
   disp = 0; // dispose = no action  
  } else {  
   transp = 1;  
   disp = 2; // force clear if using transparent color  
  }  
  if (dispose >= 0) {  
   disp = dispose & 7; // user override  
  }  
  disp <<= 2;  
  // packed fields  
  out.write(0 | // 1:3 reserved  
      disp | // 4:6 disposal  
         0 | // 7   user input - 0 = none  
       transp); // 8   transparency flag  
  writeShort(delay); // delay x 1/100 sec  
  out.write(transIndex); // transparent color index  
  out.write(0); // block terminator  
 }  
 /**  
  * Writes Image Descriptor  
  */  
 protected void writeImageDesc() throws IOException {  
  out.write(0x2c); // image separator  
  writeShort(0); // image position x,y = 0,0  
  writeShort(0);  
  writeShort(width); // image size  
  writeShort(height);  
  // packed fields  
  if (firstFrame) {  
   // no LCT  - GCT is used for first (or only) frame  
   out.write(0);  
  } else {  
   // specify normal LCT  
   out.write(0x80 | // 1 local color table  1=yes  
       0 | // 2 interlace - 0=no  
       0 | // 3 sorted - 0=no  
       0 | // 4-5 reserved  
       palSize); // 6-8 size of color table  
  }  
 }  
 /**  
  * Writes Logical Screen Descriptor  
  */  
 protected void writeLSD() throws IOException {  
  // logical screen size  
  writeShort(width);  
  writeShort(height);  
  // packed fields  
  out.write((0x80 | // 1   : global color table flag = 1 (gct used)  
       0x70 | // 2-4 : color resolution = 7  
       0x00 | // 5   : gct sort flag = 0  
      palSize)); // 6-8 : gct size  
  out.write(0); // background color index  
  out.write(0); // pixel aspect ratio - assume 1:1  
 }  
 /**  
  * Writes Netscape application extension to define  
  * repeat count.  
  */  
 protected void writeNetscapeExt() throws IOException {  
  out.write(0x21); // extension introducer  
  out.write(0xff); // app extension label  
  out.write(11); // block size  
  writeString("NETSCAPE" + "2.0"); // app id + auth code  
  out.write(3); // sub-block size  
  out.write(1); // loop sub-block id  
  writeShort(repeat); // loop count (extra iterations, 0=repeat forever)  
  out.write(0); // block terminator  
 }  
 /**  
  * Writes color table  
  */  
 protected void writePalette() throws IOException {  
  out.write(colorTab, 0, colorTab.length);  
  int n = (3 * 256) - colorTab.length;  
  for (int i = 0; i < n; i++) {  
   out.write(0);  
  }  
 }  
 /**  
  * Encodes and writes pixel data  
  */  
 protected void writePixels() throws IOException {  
  LZWEncoder encoder =  
   new LZWEncoder(width, height, indexedPixels, colorDepth);  
  encoder.encode(out);  
 }  
 /**  
  *    Write 16-bit value to output stream, LSB first  
  */  
 protected void writeShort(int value) throws IOException {  
  out.write(value & 0xff);  
  out.write((value >> 8) & 0xff);  
 }  
 /**  
  * Writes string to output stream  
  */  
 protected void writeString(String s) throws IOException {  
  for (int i = 0; i < s.length(); i++) {  
   out.write((byte) s.charAt(i));  
  }  
 }  
}