java 验证码 彩色验证码

import java.io.OutputStream;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.commons.lang.StringUtils;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;

/**
 * MyEclipse Struts
 * Creation date: 09-12-2006
 *
 * XDoclet definition:
 * @struts.action validate="true"
 */
public class ImageAction extends Action {

 // --------------------------------------------------------- Instance Variables

 // --------------------------------------------------------- Methods
// private AutocodeImage autocode = new AutocodeImage();
 /**
  * Method execute
  * @param mapping
  * @param form
  * @param request
  * @param response
  * @return ActionForward
  */
 public ActionForward execute (
  ActionMapping mapping,
  ActionForm form,
  HttpServletRequest request,
  HttpServletResponse response) throws Exception{

  // TODO Auto-generated method stub
  HttpSession session = request.getSession(true);
  String ustr = Uuid.create().toString();
  StringBuffer rand = new StringBuffer();
  for(int i=0;i<4;i++){
   int randstr = RandomUtils.buildIntRandomBy(33);
   //randstr为0的时候会出错,导致图片出不来,从新生产随机数
   while(randstr==0){
    randstr = RandomUtils.buildIntRandomBy(33);
   }
   rand.append(ustr.substring(randstr -1, randstr));
  }
  OutputStream out = response.getOutputStream();
  ImageCode.WriteImage(rand.toString(),out);
  session.setAttribute("rand",rand.toString());
  return null;
 }
 

}

页面:
   <input type="text"  name="verifyCode"  style="width:100px" maxlength="32">
<img src="image.do?rand = Math.random()"  alt="点击图更换图片" width="51" height="23" align="absbottom" id="verImg" onclick="nchangeImg();" style="cursor:hand "/>     
sturts.confix:
<action path="/image" type="gdhb.portal.action.ImageAction"/>
提交后处理:
  String verifyCode = this.getFormElementString(form, "verifyCode", "");
  if(!verifyCode.equals(request.getSession().getAttribute("rand"))){
   request.setAttribute(Constants.EXCEPTION_DEFAULT_KEY,"对不起,验证码有误,请重新填写！");
   return actionMapping.findForward("loginforward");

import javax.imageio.ImageIO;

public class ImageCode {
 /**
  * 画出随机认证码
  * @param rand 随机数
  * @param out 
  * @return  String 生成的认证码
  */
 public static void WriteImage(String rand,OutputStream out){
   
  int width = 60,height=20;
  //创建一个图形对象，类型为RGB
  BufferedImage image = new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);
  //获取图形上下文对象
  Graphics g = image.getGraphics();
  
  //设置背景色
  g.setColor(Color.GREEN);      //设置颜色 白色
  g.fillRect(0,0,width,height); //填充坐标范围内颜色
  
  //画边框
  g.setColor(Color.black);
  g.drawRect(0,0,width-1,height-1);
  
  //将认证码画入刚画的图象中
  g.setColor(Color.black);
  g.setFont(new Font("Times New Romm",Font.PLAIN,18));
  g.drawString(rand,10,15);
  //随机画88个随机干扰点，使认证码不易被其它程序探测到
  Random random = new Random();
  for(int i=0;i<88;i++){
   int x = random.nextInt(width);
   int y = random.nextInt(height);
   g.drawLine(x,y,x,y);
  }
  //释放上下文所有资源
  g.dispose();  
  //输出图象到页面
  try {
   ImageIO.write(image,"JPEG",out);
  } catch (IOException e) {   
   e.printStackTrace();
  }  
  
 }
}

import org.apache.commons.lang.StringUtils;

/**
 * <p>Title: 产生随机数的工具类。</p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2003</p>
 * <p>Company: </p>
 * @author 郑伟
 * @version 1.0
 */

public class RandomUtils
{
    private static final Random random = new Random();

    private RandomUtils()
    {
//     random = new Random();
    }
   
    /**
     * 生成num个长度为length的字符串（字符串各不相同）,字符串只包含字母
     * @param length 字符串的长度
     * @param num 字符串的个数
     * @return
     */
    public static String[] random(final int length, final int num)
    {
     return new RandomUtils().buildRandom(length, num);
    }
   
    /**
     *  生成长度为length的字符串,字符串只包含数字
     * @param length 字符串的长度
     * @return
     */
    public static String random(final int length)
    {
     return new RandomUtils().buildRandom(length);
    }
   
   
    /**
     * 生成num个长度为length的字符串，组成如 123-123-123 格式(只包含数字)
     * @param length
     * @param num
     * @return
     * @throws BaseException
     *
     * @author 张海波
     */
    public static String randombunch(int length,int num)  {
  StringBuffer str = new StringBuffer();
  for(int i = 0;i<num;i++){
   str.append(RandomUtils.random(length));
   if(i != num -1)
    str.append("-");
  }  
  return str.toString();
 }

   /**
    * 生成num个长度为length的字符串（字符串各不相同）,字符串只包含字母
    * @param length 字符串的长度
    * @param num 字符串的个数
    * @return
    */
    private String[] buildRandom (final int length, final int num) {
        if (num < 1 || length < 1) {
            return null;
        }
        Set<String> tempRets = new HashSet<String>(num);  //存放临时结果，以避免重复值的发生
       
        //生成num个不相同的字符串
        while (tempRets.size() < num) {
            tempRets.add(buildRandom(length));
        }
       
        String[] rets = new String[num];       
        rets = tempRets.toArray(rets);
        return rets;
    }
   
    /**
     * 返回指定位数的整数
     * @param length
     * @return
     *
     * @author 张海波
     */    
    public static int buildIntRandom(final int length){
     String maxStr = StringUtils.rightPad("1",length +1,'0');     
     long max = Long.parseLong(maxStr);
     long i = Math.abs(random.nextLong()) % max;
     String rand = String.valueOf(i);   
     return Integer.parseInt(rand);
    }
   
    /**
     * 取小于指定范围内的整数
     * @param length
     * @return
     *
     * @author 张海波
     */
    public static int buildIntRandomBy(final int length){
     return (int)(Math.random()*length);
    }
   
    /**
     *  生成长度为length的字符串,字符串只包含数字
     * @param length 字符串的长度
     * @return
     */
    private String buildRandom (final int length) {
        //长度为length的最多整数
        String maxStr = StringUtils.rightPad("1", length + 1, '0');
//        System.out.println("maxStr=" + maxStr);
        long max = Long.parseLong(maxStr);
        long i = random.nextLong();  //取得随机数
//        System.out.println("befor i=" + i);
        i = Math.abs(i) % max;  //取正数，并限制其长度
//        System.out.println("after i=" + i);
        String value = StringUtils.leftPad(String.valueOf(i), length, '0');
//        System.out.println("length=" + length);
//        System.out.println("value=" + value);
        return value;
    }

}

import java.io.*;
import java.net.*;
import gdhb.portal.exception.UuidException;

public class Uuid implements Serializable{
 private static final long serialVersionUID = 1118990168975148476L;
 private long high;
    private long low;
    private transient String str36;
    private static int UUID_HOST_LOCK_PORT = 5504;
    private static final int MAX_RETRYS = 1200;
    private static final int INTERVAL_TIME = 100;
    private static ServerSocket lockSocket;
    private static long timeStamp;
    private static long adapterAddress;
    private static int instanceCounter;
    private static final long versionMask = 4096L;
    private static final long reserveMask = 0xe000000000000000L;
    private static final long randomMask = 0x1fffffffL;
    private static final char hexDigits[] = {
         '0', '1', '2', '3', '4', '5', '6',
         '7', '8', '9',
         'a', 'b', 'c', 'd', 'e', 'f'
    };

    public static synchronized Uuid create() throws UuidException {
 if (timeStamp == 0L)
     setTimeStamp();
 if (adapterAddress == 0L)
     setAdapterAddress();
 Uuid uuid = new Uuid();
 long midTime = timeStamp >> 32 & 0xffffffffL;
 uuid.high = timeStamp << 32 | midTime << 16 & 0xffff0000L | 4096L |
      timeStamp >> 48 & 4095L;
 int count = instanceCounter++;
 if (count == 0x1fffffff) {
     instanceCounter = 0;
     setTimeStamp();
 }
 uuid.low = ((long) count & 0x1fffffffL) << 32 | 0xe000000000000000L |
     adapterAddress;
 return uuid;
    }

    private Uuid() {
 str36 = null;
    }

    private Uuid(long high, long low) {
 str36 = null;
 this.high = high;
 this.low = low;
    }

    private static void setAdapterAddress() throws UuidException {
 try {
     byte addr[] = InetAddress.getLocalHost().getAddress();
     int raw = addr[3] & 0xff | addr[2] << 8 & 0xff00 |
        addr[1] << 16 & 0xff0000 | addr[0] << 24 & 0xff000000;
     adapterAddress = (long) raw & 0xffffffffL;
 } catch (UnknownHostException e) {
     throw new UuidException("Unexpected failure");
 }
    }

    private static void setTimeStamp() throws UuidException {
 acquireHostLock();
 try {
     long newTime = System.currentTimeMillis();
     if (timeStamp != 0L) {
  if (newTime < timeStamp)
      throw new UuidException("Unique identifier clock failure");
  if (newTime == timeStamp) {
      letClockTick(newTime);
      newTime = System.currentTimeMillis();
  }
     }
     timeStamp = newTime;
 } finally {
     releaseHostLock();
 }
    }

    private static void letClockTick(long curTime) throws UuidException {
 int timeoutCounter = 0;
 long sleepTime = 1L;
 for (long newTime = System.currentTimeMillis(); newTime == curTime;
       newTime = System.currentTimeMillis()) {
     timeoutCounter++;
     sleepTime *= 2L;
     try {
  Thread.sleep(sleepTime);
     } catch (InterruptedException e) {}
     if (sleepTime > 60000L)
  throw new UuidException("Unique identifier unexpected failure");
 }

    }

    private static void acquireHostLock() throws UuidException {
 String portProperty = null;
 try {
     portProperty = System.getProperty("bluewater.uuid.hostLockPort");
 } catch (SecurityException e) {}
 if (portProperty != null)
     try {
  UUID_HOST_LOCK_PORT = Integer.parseInt(portProperty);
     } catch (NumberFormatException nfe) {}
 for (int numberOfRetrys = 0; lockSocket == null; numberOfRetrys++) {
     try {
  lockSocket = new ServerSocket(UUID_HOST_LOCK_PORT);
  return;
     } catch (BindException e) {} catch (IOException e2) {
  throw new UuidException("Unique identifier unexpected failure");
     }
     try {
  Thread.sleep(100L);
     } catch (InterruptedException e1) {}
     if (numberOfRetrys == 1200)
  throw new UuidException("Unique identifier lock failure");
 }

    }

    private static void releaseHostLock() {
 if (lockSocket != null) {
     try {
  lockSocket.close();
     } catch (IOException e) {}
     lockSocket = null;
 }
    }

    public boolean equals(Object obj) {
 if (obj != null && (obj instanceof Uuid))
     return high == ((Uuid) obj).high && low == ((Uuid) obj).low;
 else
     return false;
    }

    public int hashCode() {
 return (int) (low << 24) & 0xff000000 | (int) (high >> 20) & 0xfff000 |
  (int) (low >> 32) & 0xfff;
    }

    public String toString() {
 if (str36 != null) {
     return str36;
 } else {
     StringBuffer buf = new StringBuffer();
     buf.append(toHexString(high >>> 32, 8)); //.append("-");
     buf.append(toHexString(high >>> 16, 4)); //.append("-");
     buf.append(toHexString(high, 4)); //.append("-");
     buf.append(toHexString(low >>> 48, 4)); //.append("-");
     buf.append(toHexString(low, 12));
     str36 = buf.toString();
     return str36;
 }
    }

    private static String toHexString(long x, int chars) {
 char buf[] = new char[chars];
 for (int charPos = chars; --charPos >= 0; ) {
     buf[charPos] = hexDigits[(int) (x & 15L)];
     x >>>= 4;
 }

 return new String(buf);
    }

    public byte[] toByteArray() {
 byte array[] = new byte[16];
 toBytes(high, array, 0);
 toBytes(low, array, 8);
 return array;
    }

    private void toBytes(long x, byte array[], int startPos) {
 for (int bytePos = 8; --bytePos >= 0; ) {
     array[startPos + bytePos] = (byte) (int) (x & 255L);
     x >>>= 8;
 }

    }

    public void write(DataOutput out) throws IOException {
 out.writeLong(high);
 out.writeLong(low);
    }

    public static Uuid read(DataInput in) throws IOException {
 long high = in.readLong();
 long low = in.readLong();
 return new Uuid(high, low);
    }

    public static Uuid read(String id) throws UuidException {
 Uuid uuid;
 String part = id.substring(0, 8);
 long high = 0L;
 high = Long.parseLong(part, 16) << 32;
 part = id.substring(9, 13);
 high |= Long.parseLong(part, 16) << 16;
 part = id.substring(14, 18);
 high |= Long.parseLong(part, 16);
 long low = 0L;
 part = id.substring(19, 23);
 low = Long.parseLong(part, 16) << 48;
 part = id.substring(24, 36);
 low |= Long.parseLong(part, 16);
 uuid = new Uuid(high, low);
 return uuid;
    }

    public static void main(String args[]) {
 try {
     long begin = System.currentTimeMillis();
     for (int i = 0; i < 1; i++) {
  Uuid uuid = create();
  System.out.println(uuid.toString());
     }

     long end = System.currentTimeMillis();
     System.out.println("total=" + (end - begin) + "ms," +
          (end - begin) / 1000L + " second");
 } catch (Exception ex) {}
    }
}
UuidException类:
public class UuidException extends RuntimeException{
 private static final long serialVersionUID = 845412579193271744L;

 public UuidException () {
 }

 public UuidException (String msg) {
  super(msg);
 }
}