java生成动态gif格式与png格式的验证码(代码1)

Java代码  


import java.awt.Color;  

import java.awt.Font;  

import java.io.OutputStream;  

import java.util.Random;  

  

/** 

 * 验证码抽象类,暂时不支持中文 

 * @author wzztestin 

 * 

 */  

public abstract class Captcha {  

    private static final Random random = new Random();  

    // 字体  

    protected Font font = new Font("Verdana", Font.ITALIC | Font.BOLD, 28);   

    // 默认宽度  

    protected int width = 150;   

    //默认高度  

    protected int height = 40;   

    //验证码串  

    private String yanzhenmastr = "";  

    //除数  

    private String onenum = "";  

      

    /** 

     * 生成随机颜色 

     * @param fc 

     * @param bc 

     * @return Color 

     */  

    Color getRandColor(int fc, int bc) {  

        Random random = new Random();  

        if (fc > 255) {  

            fc = 255;  

        }  

        if (bc > 255) {  

            bc = 255;  

        }  

        int r = fc + random.nextInt(bc - fc);  

        int g = fc + random.nextInt(bc - fc);  

        int b = fc + random.nextInt(bc - fc);  

        return new Color(r, g, b);  

    }  

      

    /** 

     * 生成随机字体 

     * @return Font 

     */  

     Font getRandomFont() {   

         String[] fonts = {"Georgia", "Verdana", "Arial", "Tahoma", "Time News Roman", "Courier New", "Arial Black", "Quantzite"};   

         int fontIndex = (int)Math.round(Math.random() * (fonts.length - 1));   

         int fontSize = 28;   

         return new Font(fonts[fontIndex], Font.PLAIN, fontSize);   

     }  

      

    public String getOnenum() {  

        return onenum;  

    }  

  

    public String getCzfu() {  

        return czfu;  

    }  

  

    public String getTwonum() {  

        return twonum;  

    }  

    //操作符  

    private String czfu = "";  

    //被除数  

    private String twonum = "";  

    public String getYanzhenmastr() {  

        return yanzhenmastr;  

    }  

  

    protected int alpha = 5;  

  

    public int getAlpha() {  

        return alpha;  

    }  

  

    public void setAlpha(int alpha) {  

        this.alpha = alpha;  

    }  

  

    /** 

     * 生成随机字符数组 

     *  

     * @return 字符数组 

     */  

    protected String getVilidCode() {  

        int numlength =  random.nextInt(2)+1;  

        for (int i = 0; i < numlength; i++) {  

            char rnum = Randoms.getNum();  

            yanzhenmastr = yanzhenmastr + rnum;  

            onenum = onenum + rnum;  

        }  

        czfu = Randoms.getChaoZuoFu()+"";  

        yanzhenmastr = yanzhenmastr + czfu;  

        for (int i = 0; i < numlength; i++) {  

            char rnum = Randoms.getNum();  

            yanzhenmastr = yanzhenmastr + rnum;  

            twonum = twonum + rnum;  

        }  

        yanzhenmastr = yanzhenmastr + "=?";  

        return yanzhenmastr;  

    }  

  

    public Font getFont() {  

        return font;  

    }  

  

    public void setFont(Font font) {  

        this.font = font;  

    }  

  

    public int getWidth() {  

        return width;  

    }  

  

    public void setWidth(int width) {  

        this.width = width;  

    }  

  

    public int getHeight() {  

        return height;  

    }  

  

    public void setHeight(int height) {  

        this.height = height;  

    }  

  

    /** 

     * 给定范围获得随机颜色 

     *  

     * @return Color 随机颜色 

     */  

    protected Color color(int fc, int bc) {  

        if (fc > 255)  

            fc = 255;  

        if (bc > 255)  

            bc = 255;  

        int r = fc + Randoms.num(bc - fc);  

        int g = fc + Randoms.num(bc - fc);  

        int b = fc + Randoms.num(bc - fc);  

        return new Color(r, g, b);  

    }  

  

    /** 

     * 验证码输出,抽象方法，由子类实现 

     *  

     * @param os 

     *            输出流 

     */  

    public abstract void out(OutputStream os);  

}  

 

Java代码  


import java.io.IOException;  

import java.io.OutputStream;  

  

/** 

 *  

 * @author wzztestin 

 * 图片编码器 

 */  

public class Encoder {  

    private static final int EOF = -1;  

  

    private int imgW, imgH;  

    private byte[] pixAry;  

    private int initCodeSize;  

    private int remaining;  

    private int curPixel;  

      

    /** 

     * GIF Image compression routines 

     */  

  

    static final int BITS = 12;  

  

    static final int HSIZE = 5003;   

  

    int n_bits;   

    int maxbits = BITS;   

    int maxcode;   

    int maxmaxcode = 1 << BITS;   

  

    int[] htab = new int[HSIZE];  

    int[] codetab = new int[HSIZE];  

  

    int hsize = HSIZE;   

  

    int free_ent = 0;   

  

    boolean clear_flg = false;  

  

    int g_init_bits;  

  

    int ClearCode;  

    int EOFCode;  

  

    int cur_accum = 0;  

    int cur_bits = 0;  

  

    int masks[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F,  

            0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF,  

            0x7FFF, 0xFFFF };  

  

    int a_count;  

  

    byte[] accum = new byte[256];  

  

    Encoder(int width, int height, byte[] pixels, int color_depth) {  

        imgW = width;  

        imgH = height;  

        pixAry = pixels;  

        initCodeSize = Math.max(2, color_depth);  

    }  

  

    void char_out(byte c, OutputStream outs) throws IOException {  

        accum[a_count++] = c;  

        if (a_count >= 254)  

            flush_char(outs);  

    }  

  

    void cl_block(OutputStream outs) throws IOException {  

        cl_hash(hsize);  

        free_ent = ClearCode + 2;  

        clear_flg = true;  

  

        output(ClearCode, outs);  

    }  

  

    void cl_hash(int hsize) {  

        for (int i = 0; i < hsize; ++i)  

            htab[i] = -1;  

    }  

  

    void compress(int init_bits, OutputStream outs) throws IOException {  

        int fcode;  

        int i ;  

        int c;  

        int ent;  

        int disp;  

        int hsize_reg;  

        int hshift;  

        g_init_bits = init_bits;  

        clear_flg = false;  

        n_bits = g_init_bits;  

        maxcode = MAXCODE(n_bits);  

        ClearCode = 1 << (init_bits - 1);  

        EOFCode = ClearCode + 1;  

        free_ent = ClearCode + 2;  

        a_count = 0;   

        ent = nextPixel();  

        hshift = 0;  

        for (fcode = hsize; fcode < 65536; fcode *= 2)  

            ++hshift;  

        hshift = 8 - hshift;   

        hsize_reg = hsize;  

        cl_hash(hsize_reg);   

        output(ClearCode, outs);  

        outer_loop: while ((c = nextPixel()) != EOF) {  

            fcode = (c << maxbits) + ent;  

            i = (c << hshift) ^ ent;   

            if (htab[i] == fcode) {  

                ent = codetab[i];  

                continue;  

            } else if (htab[i] >= 0)  

            {  

                disp = hsize_reg - i;  

                if (i == 0)  

                    disp = 1;  

                do {  

                    if ((i -= disp) < 0)  

                        i += hsize_reg;  

  

                    if (htab[i] == fcode) {  

                        ent = codetab[i];  

                        continue outer_loop;  

                    }  

                } while (htab[i] >= 0);  

            }  

            output(ent, outs);  

            ent = c;  

            if (free_ent < maxmaxcode) {  

                codetab[i] = free_ent++;  

                htab[i] = fcode;  

            } else  

                cl_block(outs);  

        }  

        output(ent, outs);  

        output(EOFCode, outs);  

    }  

  

    void encode(OutputStream os) throws IOException {  

        os.write(initCodeSize);   

  

        remaining = imgW * imgH;   

        curPixel = 0;  

  

        compress(initCodeSize + 1, os);   

  

        os.write(0);   

    }  

  

    void flush_char(OutputStream outs) throws IOException {  

        if (a_count > 0) {  

            outs.write(a_count);  

            outs.write(accum, 0, a_count);  

            a_count = 0;  

        }  

    }  

  

    final int MAXCODE(int n_bits) {  

        return (1 << n_bits) - 1;  

    }  

  

    private int nextPixel() {  

        if (remaining == 0)  

            return EOF;  

  

        --remaining;  

  

        byte pix = pixAry[curPixel++];  

  

        return pix & 0xff;  

    }  

  

    void output(int code, OutputStream outs) throws IOException {  

        cur_accum &= masks[cur_bits];  

  

        if (cur_bits > 0)  

            cur_accum |= (code << cur_bits);  

        else  

            cur_accum = code;  

  

        cur_bits += n_bits;  

  

        while (cur_bits >= 8) {  

            char_out((byte) (cur_accum & 0xff), outs);  

            cur_accum >>= 8;  

            cur_bits -= 8;  

        }  

  

        if (free_ent > maxcode || clear_flg) {  

            if (clear_flg) {  

                maxcode = MAXCODE(n_bits = g_init_bits);  

                clear_flg = false;  

            } else {  

                ++n_bits;  

                if (n_bits == maxbits)  

                    maxcode = maxmaxcode;  

                else  

                    maxcode = MAXCODE(n_bits);  

            }  

        }  

  

        if (code == EOFCode) {  

            while (cur_bits > 0) {  

                char_out((byte) (cur_accum & 0xff), outs);  

                cur_accum >>= 8;  

                cur_bits -= 8;  

            }  

  

            flush_char(outs);  

        }  

    }  

}