汉字验证码

Java代码
package com.toy;  
 
import java.util.Random;  
import java.io.UnsupportedEncodingException;  
import java.io.OutputStream;  
import java.awt.image.BufferedImage;  
import javax.imageio.ImageIO;  
import java.awt.*;  
import java.io.*;  
 
/** 
* 一个能生成验证码的类 
* 默认四个汉字 
* 使用该类生成验证码时 
* @author jiangjizhong 
*/ 
public class VerifyCode {  
 
    private final Random random = new Random(System.nanoTime());  
    private int width;  
    private int height;  
    private int charNumber = 4;  
    private float yawpRate = 0.2f; //噪声率  
    private OutputStream outputStream;  
    private char[] code;  
      
    public VerifyCode() {  
        //empty  
    }  
 
    /** 
     * 返回生成的验证码字符串 
     * @return 
     */ 
    public String getVerifyCode(){  
        return new String(code);  
    }  
      
    public VerifyCode(int width, int height) {  
        this.width = width;  
        this.height = height;  
    }  
 
    private void drawPane(Graphics2D g2d){  
        g2d.setColor(Color.BLACK);  
        g2d.setStroke(new BasicStroke(2.0f));  
        g2d.drawRect(0, 0, width, height);  
    }  
      
    private void drawChars(Graphics2D g2d){  
        float scale = 1f;  
        int size = (int) (scale * height);  
        int offsetHeight = (height + size) / 2;  
        StringBuffer sb = new StringBuffer(1);  
        sb.setLength(1);  
        g2d.setColor(Color.BLACK);  
        code = new char[charNumber];  
        for (int i = 0; i < charNumber; i++) {  
            //计算第i个字的x偏移  
            int offsetWidth = i * size;  
            //随机大小  
            int charSize = this.getRandomIntBetween((int) (size * 0.5), size);  
            //随机样式  
            int fontStyle = this.getRandomBoolean() ? Font.ITALIC : Font.ITALIC;  
            g2d.setFont(new Font("隶书", fontStyle, charSize));  
            //随机颜色  
            //g2d.setColor(this.getRandomColor());  
            //随机上移一点  
            int moveUp = random.nextInt((int) (0.3 * height));  
            //随机字符  
            char c = this.getRandomChar();  
            code[i] = c;  
            sb.setCharAt(0, c);  
            g2d.drawString(sb.toString(), offsetWidth, offsetHeight - moveUp);  
        }  
    }  
      
    private void drawSmallChars(Graphics2D g2d){  
        final int lines = 5;  
        int fontSize = this.getHeight() / lines;  
        int number = this.getWidth() / fontSize;  
        g2d.setFont(new Font("隶书", Font.PLAIN, fontSize));  
        g2d.setColor(this.getRandomColor());  
        for(int i=0; i<10;i++){  
            StringBuffer sb = new StringBuffer(number);  
            for(int j=0; j<number; j++){  
                sb.append(this.getRandomChar());  
            }  
            g2d.drawString(sb.toString(), 0, (i + 1) * fontSize);  
        }  
    }  
    /** 
     * 主要方法，开始生成 
     */ 
    public void write() {  
        BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);  
        Graphics2D g2d = bi.createGraphics();  
        g2d.setColor(Color.WHITE);  
        g2d.fillRect(0, 0, width, height);  
        //画方框9/10期望宽度  
        this.drawPane(g2d);  
        //设定字体,字体大小为4/5方框，居中  
        this.drawChars(g2d);  
/*补充注释：有些人添加干扰时，喜欢使用随机线条。我认为这个方法一点都不好，不仅是图片极度丑陋，而且根本起不到干扰的作用。*/ 
        //背景上随机10行小字  
        this.drawSmallChars(g2d);  
        //添加噪点  
        int area = (int) (this.getYawpRate() * height * width);  
        for (int i = 0; i < area; i++) {  
            int x = random.nextInt(width);  
            int y = random.nextInt(height);  
            int rgb = this.getRandomIntColor();  
            bi.setRGB(x, y, rgb);  
        }  
 
        try {  
            ImageIO.write(bi, "jpeg", outputStream);  
        } catch (Exception exc) {  
            exc.printStackTrace();  
        }  
    }  
 
    private boolean getRandomBoolean() {  
        int randInt = random.nextInt(10);  
        if (randInt > 4) {  
            return true;  
        } else {  
            return false;  
        }  
    }  
 
    private Color getRandomColor() {  
        int[] rgb = this.getRandomRgb();  
        return new Color(rgb[0], rgb[1], rgb[2]);  
    }  
 
    private int getRandomIntColor() {  
        int[] rgb = this.getRandomRgb();  
        int color = 0;  
        for (int c : rgb) {  
            color = color << 8;  
            color = color | c;  
        }  
        return color;  
    }  
 
    private int[] getRandomRgb() {  
        int[] rgb = new int[3];  
        for (int i = 0; i < 3; i++) {  
            rgb[i] = random.nextInt(255);  
        }  
        return rgb;  
    }  
 
    /** 
     * 返回一个随机汉字字符。 
     * 采用随机生成两个byte按gb2312编码构成一个String的算法。 
     * 两个字节在B0A1到D7F9之间，是常用简体字 
     * 所以，第一个字节在B0(十进制176)到D7(十进制215)之间，第二个字节在A1(十进制161)到F9(十进制249)之间 
     * @return 
     */ 
    protected char getRandomChar() {  
        final int minFirstByte = 176;  
        final int maxFirstByte = 215;  
        final int minSecondByte = 161;  
        final int maxSecondByte = 249;  
 
        byte[] b = new byte[2];  
        b[0] = (byte) (getRandomIntBetween(minFirstByte, maxFirstByte));  
        b[1] = (byte) (getRandomIntBetween(minSecondByte, maxSecondByte));  
        try {  
            String s = new String(b, "gb2312");  
            assert s.length() == 1;  
            return s.charAt(0);  
        } catch (UnsupportedEncodingException uee) {  
            //重试  
            return getRandomChar();  
        }  
    }  
 
    /** 
     * 获取两个整数之间的某个随机数，包含较小的整数，不包含较大的整数 
     * @param first 
     * @param second 
     * @return 随机数 
     */ 
    private int getRandomIntBetween(int first, int second) {  
        if (second < first) {  
            int tmp = first;  
            first = second;  
            second = tmp;  
        }  
        return random.nextInt(second - first) + first;  
    }  
      
    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;  
    }  
 
    public OutputStream getOutputStream() {  
        return outputStream;  
    }  
 
    /** 
     * 验证码输出地址，如果是在jsp或servlet里使用，这里的outputStream就是从Response对象里获取的outputStream 
     */ 
    public void setOutputStream(OutputStream outputStream) {  
        this.outputStream = outputStream;  
    }  
 
    public int getCharNumber() {  
        return charNumber;  
    }  
 
    /** 
      * 生成验证码的字符数量，默认四个 
      */ 
    public void setCharNumber(int charNumber) {  
        this.charNumber = charNumber;  
    }  
 
    public float getYawpRate() {  
        return yawpRate;  
    }  
 
    /** 
     * 设定噪声率，既图像上出现的噪声像素占全部像素的比例 
     * @param yawpRate 
     */ 
    public void setYawpRate(float yawpRate) {  
        this.yawpRate = yawpRate;  
    }  
} 

package com.toy;

import java.util.Random;
import java.io.UnsupportedEncodingException;
import java.io.OutputStream;
import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;
import java.awt.*;
import java.io.*;

/**
* 一个能生成验证码的类
* 默认四个汉字
* 使用该类生成验证码时
* @author jiangjizhong
*/
public class VerifyCode {

    private final Random random = new Random(System.nanoTime());
    private int width;
    private int height;
    private int charNumber = 4;
    private float yawpRate = 0.2f; //噪声率
    private OutputStream outputStream;
    private char[] code;
   
    public VerifyCode() {
        //empty
    }

    /**
     * 返回生成的验证码字符串
     * @return
     */
    public String getVerifyCode(){
        return new String(code);
    }
   
    public VerifyCode(int width, int height) {
        this.width = width;
        this.height = height;
    }

    private void drawPane(Graphics2D g2d){
        g2d.setColor(Color.BLACK);
        g2d.setStroke(new BasicStroke(2.0f));
        g2d.drawRect(0, 0, width, height);
    }
   
    private void drawChars(Graphics2D g2d){
        float scale = 1f;
        int size = (int) (scale * height);
        int offsetHeight = (height + size) / 2;
        StringBuffer sb = new StringBuffer(1);
        sb.setLength(1);
        g2d.setColor(Color.BLACK);
        code = new char[charNumber];
        for (int i = 0; i < charNumber; i++) {
            //计算第i个字的x偏移
            int offsetWidth = i * size;
            //随机大小
            int charSize = this.getRandomIntBetween((int) (size * 0.5), size);
            //随机样式
            int fontStyle = this.getRandomBoolean() ? Font.ITALIC : Font.ITALIC;
            g2d.setFont(new Font("隶书", fontStyle, charSize));
            //随机颜色
            //g2d.setColor(this.getRandomColor());
            //随机上移一点
            int moveUp = random.nextInt((int) (0.3 * height));
            //随机字符
            char c = this.getRandomChar();
            code[i] = c;
            sb.setCharAt(0, c);
            g2d.drawString(sb.toString(), offsetWidth, offsetHeight - moveUp);
        }
    }
   
    private void drawSmallChars(Graphics2D g2d){
        final int lines = 5;
        int fontSize = this.getHeight() / lines;
        int number = this.getWidth() / fontSize;
        g2d.setFont(new Font("隶书", Font.PLAIN, fontSize));
        g2d.setColor(this.getRandomColor());
        for(int i=0; i<10;i++){
            StringBuffer sb = new StringBuffer(number);
            for(int j=0; j<number; j++){
                sb.append(this.getRandomChar());
            }
            g2d.drawString(sb.toString(), 0, (i + 1) * fontSize);
        }
    }
    /**
     * 主要方法，开始生成
     */
    public void write() {
        BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        Graphics2D g2d = bi.createGraphics();
        g2d.setColor(Color.WHITE);
        g2d.fillRect(0, 0, width, height);
        //画方框9/10期望宽度
        this.drawPane(g2d);
        //设定字体,字体大小为4/5方框，居中
        this.drawChars(g2d);
/*补充注释：有些人添加干扰时，喜欢使用随机线条。我认为这个方法一点都不好，不仅是图片极度丑陋，而且根本起不到干扰的作用。*/
        //背景上随机10行小字
        this.drawSmallChars(g2d);
        //添加噪点
        int area = (int) (this.getYawpRate() * height * width);
        for (int i = 0; i < area; i++) {
            int x = random.nextInt(width);
            int y = random.nextInt(height);
            int rgb = this.getRandomIntColor();
            bi.setRGB(x, y, rgb);
        }

        try {
            ImageIO.write(bi, "jpeg", outputStream);
        } catch (Exception exc) {
            exc.printStackTrace();
        }
    }

    private boolean getRandomBoolean() {
        int randInt = random.nextInt(10);
        if (randInt > 4) {
            return true;
        } else {
            return false;
        }
    }

    private Color getRandomColor() {
        int[] rgb = this.getRandomRgb();
        return new Color(rgb[0], rgb[1], rgb[2]);
    }

    private int getRandomIntColor() {
        int[] rgb = this.getRandomRgb();
        int color = 0;
        for (int c : rgb) {
            color = color << 8;
            color = color | c;
        }
        return color;
    }

    private int[] getRandomRgb() {
        int[] rgb = new int[3];
        for (int i = 0; i < 3; i++) {
            rgb[i] = random.nextInt(255);
        }
        return rgb;
    }

    /**
     * 返回一个随机汉字字符。
     * 采用随机生成两个byte按gb2312编码构成一个String的算法。
     * 两个字节在B0A1到D7F9之间，是常用简体字
     * 所以，第一个字节在B0(十进制176)到D7(十进制215)之间，第二个字节在A1(十进制161)到F9(十进制249)之间
     * @return
     */
    protected char getRandomChar() {
        final int minFirstByte = 176;
        final int maxFirstByte = 215;
        final int minSecondByte = 161;
        final int maxSecondByte = 249;

        byte[] b = new byte[2];
        b[0] = (byte) (getRandomIntBetween(minFirstByte, maxFirstByte));
        b[1] = (byte) (getRandomIntBetween(minSecondByte, maxSecondByte));
        try {
            String s = new String(b, "gb2312");
            assert s.length() == 1;
            return s.charAt(0);
        } catch (UnsupportedEncodingException uee) {
            //重试
            return getRandomChar();
        }
    }

    /**
     * 获取两个整数之间的某个随机数，包含较小的整数，不包含较大的整数
     * @param first
     * @param second
     * @return 随机数
     */
    private int getRandomIntBetween(int first, int second) {
        if (second < first) {
            int tmp = first;
            first = second;
            second = tmp;
        }
        return random.nextInt(second - first) + first;
    }
   
    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;
    }

    public OutputStream getOutputStream() {
        return outputStream;
    }

/**
* 验证码输出地址，如果是在jsp或servlet里使用，这里的outputStream就是从Response对象里获取的outputStream
*/
    public void setOutputStream(OutputStream outputStream) {
        this.outputStream = outputStream;
    }

    public int getCharNumber() {
        return charNumber;
    }

/**
  * 生成验证码的字符数量，默认四个
  */
    public void setCharNumber(int charNumber) {
        this.charNumber = charNumber;
    }

    public float getYawpRate() {
        return yawpRate;
    }

    /**
     * 设定噪声率，既图像上出现的噪声像素占全部像素的比例
     * @param yawpRate
     */
    public void setYawpRate(float yawpRate) {
        this.yawpRate = yawpRate;
    }
}
 
使用该验证码的jsp文件：



Java代码
<%@page contentType="image/jpeg" pageEncoding="UTF-8" import="com.toy.*;"%>  
<%  
    out.clear();  
    response.reset();  
    //设定相应头  
    //不缓存  
    response.setHeader("Pragma","No-cache");  
    response.setHeader("Cache-Control","no-cache");  
    response.setDateHeader("Expires", 0);  
 
    int height = 50;//验证码图片高度  
    int width = 200;//验证码图片宽度  
    int charNumber = 4;  
    if(request.getParameter("height") != null){  
        height = Integer.parseInt(request.getParameter("height"));  
    }  
    if(request.getParameter("width") != null){  
        width = Integer.parseInt(request.getParameter("width"));  
    }  
    if(request.getParameter("charnum") != null){  
        charNumber = Integer.parseInt(request.getParameter("charNumber"));  
    }  
    VerifyCode vc = new VerifyCode(width, height);  
    vc.setCharNumber(charNumber);  
    vc.setOutputStream(response.getOutputStream());  
    vc.write();  
    session.setAttribute("VerifyCode", vc.getVerifyCode());  
%>