自己寫一個圖片驗證碼程序

本程序基於struts2，用action響應請求。

一、首先，創建一個用於產生隨即驗證碼圖片的類ImageCode.java.

package com.exp.image;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Random;

import javax.ejb.Init;
import javax.imageio.ImageIO;
import javax.imageio.stream.ImageOutputStream;

public class ImageCode {
    private static Random random = new Random();// 隨機數對象
    private static ByteArrayInputStream inputStream;// 字節數組輸入流對象
    private static String randString;// 隨機生成的字符串
    private static ImageCode imageCode;// 本類對象
    // 以下是系統默認參數
    private static int nums = 6;// 驗證碼位數
    private static int width = 80;// 圖片寬
    private static int height = 22;// 圖片高
    private static int left = 4;// 字符輸出左邊距
    private static int top = 18;// 字符輸出上邊距
    private static int fontSize = 22;// 字符輸出上邊距
    private static String charSet = "0123456789abcdefghijklmnpqrstuvwxyzABCDEFGHIJKLMNPQRSTUVWXYZ";// 驗證碼字符集合
    private static int stringMinColor = 100;// 字符最低顏色值
    private static int stringMaxColor = 177;// 字符最高顏色值
    private static int otherMinColor = 178;// 干擾線和噪點最低顏色值
    private static int otherMaxColor = 255;// 干擾線和噪點最高顏色值
    private static Color backgroundColor = Color.cyan;// 圖片背景色
    private static boolean isShear = false;// 是否進行字符扭曲

    /**
     * 單例模式
     */
    static {
        if (imageCode == null) {
            imageCode = new ImageCode();
        }
    }

    /**
     * 設置綜合信息
     * 
     * @param nums
     *            驗證碼位數
     * @param width
     *            圖片寬度，默認值80
     * @param height
     *            圖片高度，默認值22
     * @param left
     *            字符輸出左邊距，默認4
     * @param top
     *            字符輸出上邊距，默認20
     * @param fontSize
     *            字符大小，默認22
     * @param charSet
     *            驗證碼字符集合字符串，默認為
     *            "0123456789abcdefghijklmnpqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
     * @param stringMinColor
     *            字符輸出最小顏色值，默認100
     * @param stringMaxColor
     *            字符輸出最大顏色值，默認177
     * @param otherMinColor
     *            干擾線和噪點最小顏色值，默認178
     * @param otherMaxColor
     *            干擾線和噪點最大顏色值，默認255
     * @param backgroundColor
     *            圖片背景色，默認Color.cyan
     * @param isShear
     *            是否進行單個字符扭曲，默認false
     */
    public static void set(int nums, int width, int height, int left, int top,
            int fontSize, String charSet, int stringMinColor,
            int stringMaxColor, int otherMinColor, int otherMaxColor,
            Color backgroundColor,boolean isShear) {
        // 設置驗證碼位數
        if (nums != 0) {
            ImageCode.nums = nums;
        }
        // 設置驗證碼圖片寬度
        if (width != 0) {
            ImageCode.width = width;
        }
        // 設置驗證碼圖片高度
        if (height != 0) {
            ImageCode.height = height;
        }
        // 設置驗證碼字符輸出左邊距
        if (left != 0) {
            ImageCode.left = left;
        }
        // 設置驗證碼字符輸出上邊距
        if (top != 0) {
            ImageCode.top = top;
        }
        // 設置驗證碼字符大小
        if (fontSize != 0) {
            ImageCode.fontSize = fontSize;
        }
        // 設置驗證碼字符集合字符串
        if (charSet != null) {
            ImageCode.charSet = charSet;
        }
        // 設置驗證碼字符輸出最小顏色值
        if (stringMinColor != 0) {
            ImageCode.stringMinColor = stringMinColor;
        }
        // 設置驗證碼字符輸出最大顏色值
        if (stringMaxColor != 0) {
            ImageCode.stringMaxColor = stringMaxColor;
        }
        // 設置驗證碼干擾線和噪點最小顏色值
        if (otherMinColor != 0) {
            ImageCode.otherMinColor = otherMinColor;
        }
        // 設置驗證碼干擾線和噪點最大顏色值
        if (otherMaxColor != 0) {
            ImageCode.otherMaxColor = otherMaxColor;
        }
        // 設置驗證碼圖片背景色
        if (backgroundColor != null) {
            ImageCode.backgroundColor = backgroundColor;
        }
        // 設置驗證碼圖片背景色
            ImageCode.isShear = isShear;
    }

    /**
     * 創建隨機圖片，生成隨機字符串
     */
    public static void createRandomImage() {
        // 建立內存圖像
        BufferedImage image = new BufferedImage(width, height,
                BufferedImage.TYPE_INT_RGB);
        // 創建圖形上下文
        Graphics2D g = image.createGraphics();
        // 消除線段的鋸齒邊緣
        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON);
        // 設置底色
        g.setColor(Color.PINK);
        // 繪制填充矩形
        g.fillRect(0, 0, width, height);
        // 繪制干擾線
        for (int i = 0; i < 200; i++) {
            g.setColor(getRandColor(otherMinColor, otherMaxColor));
            g.setStroke(new BasicStroke(1f));
            int x1 = random.nextInt(width);
            int y1 = random.nextInt(height);
            int x2 = random.nextInt(width * 2);
            int y2 = random.nextInt(height * 2);
            g.drawLine(x1, y1, x2, y2);
        }

        // 獲得字符串
        StringBuffer sBuffer = new StringBuffer();

        // 按位數拼接隨機字符串
        for (int i = 0; i < nums; i++) {
            // 根據隨機數在charSet中尋找字符
            sBuffer.append(charSet.charAt(random.nextInt(charSet.length())));
        }
        String code = sBuffer.toString();// 這個字符串是包含大小寫字母的，不包括Oo
        setRandString(code.toLowerCase());// 所有字母轉小寫

        // 繪制字符串
        if (isShear) {
            // 字符逐個扭曲輸出
            shearEveryChar(g, code, 0, 127);
        } else {
            // 輸出字符串，這是不進行單個字符扭曲的選擇
            g.setColor(getRandColor(stringMinColor, stringMaxColor));
            g.setFont(new Font("黑體", Font.BOLD + Font.ITALIC, 22));
            g.drawString(code, left, top);
        }

        // 繪制噪點
        drawNoise(g, image, 0.05f);

        // 扭曲整個圖片
        // shear(g, width, height, getRandColor(128, 255));// 使圖片扭曲

        // 設置輸出流
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        try {
            ImageOutputStream ios = ImageIO.createImageOutputStream(bos);
            ImageIO.write(image, "jpg", ios);
            ByteArrayInputStream bis = new ByteArrayInputStream(
                    bos.toByteArray());
            setInputStream(bis);
            bos.flush();
            bis.close();
            ios.close();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bos.flush();
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

    /**
     * 繪制噪點
     * 
     * @param g
     * @param image
     * @param yRote
     */
    public static void drawNoise(Graphics2D g, BufferedImage image, float yRote) {
        int area = (int) (yRote * width * height);
        for (int i = 0; i < area; i++) {
            g.setStroke(new BasicStroke(2f));
            int x = random.nextInt(width);
            int y = random.nextInt(height);
            int rgb = getRandomIntColor();
            image.setRGB(x, y, rgb);
        }
    }

    /**
     * 字符逐個扭曲輸出
     * 
     * @param g
     * @param code
     */
    public static void shearEveryChar(Graphics2D g, String code,
            int stringMinColor, int stringMaxColor) {
        int fontSize = height - 4;
        Font font = new Font("黑體", Font.BOLD + Font.ITALIC, fontSize);
        g.setFont(font);
        char[] chars = code.toCharArray();
        for (int i = 0; i < code.length(); i++) {
            g.setColor(getRandColor(stringMinColor, stringMaxColor));
            AffineTransform affine = new AffineTransform();
            affine.setToRotation(
                    Math.PI / 4 * random.nextDouble()
                            * (random.nextBoolean() ? 1 : -1),
                    (width / code.length()) * i + fontSize / 2, height / 2);
            g.setTransform(affine);
            g.drawChars(chars, i, 1, ((width - 10) / code.length()) * i + 5,
                    height / 2 + fontSize / 2 - 3);
        }
    }

    /**
     * 獲得隨機顏色
     * 
     * @param fc
     *            顏色起始值
     * @param bc
     *            顏色終止值
     * @return 返回Color對象
     */
    private static Color getRandColor(int fc, int bc) {
        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
     */
    private static int getRandomIntColor() {
        int[] rgb = getRandomRgb();
        int color = 0;
        for (int c : rgb) {
            color = color << 8;
            color = color | c;
        }
        return color;
    }

    /**
     * 獲得隨機數組，適配整數類型的顏色值
     * 
     * @return
     */
    private static int[] getRandomRgb() {
        int[] rgb = new int[3];
        for (int i = 0; i < 3; i++) {
            rgb[i] = random.nextInt(255);
        }
        return rgb;
    }

    // 整個圖片扭曲
    private static void shear(Graphics g, int w1, int h1, Color color) {
        shearX(g, w1, h1, color);
        shearY(g, w1, h1, color);
    }

    // X軸扭曲
    private static void shearX(Graphics g, int w1, int h1, Color color) {
        int period = random.nextInt(2);
        boolean borderGap = true;
        int frames = 1;
        int phase = random.nextInt(2);

        for (int i = 0; i < h1; i++) {
            double d = (double) (period >> 1)
                    * Math.sin((double) i / (double) period
                            + (6.2831853071795862D * (double) phase)
                            / (double) frames);
            g.copyArea(0, i, w1, 1, (int) d, 0);
            if (borderGap) {
                g.setColor(color);
                g.drawLine((int) d, i, 0, i);
                g.drawLine((int) d + w1, i, w1, i);
            }
        }

    }

    // Y軸扭曲
    private static void shearY(Graphics g, int w1, int h1, Color color) {
        int period = random.nextInt(40) + 10; // 50;
        boolean borderGap = true;
        int frames = 20;
        int phase = 7;
        for (int i = 0; i < w1; i++) {
            double d = (double) (period >> 1)
                    * Math.sin((double) i / (double) period
                            + (6.2831853071795862D * (double) phase)
                            / (double) frames);
            g.copyArea(i, 0, 1, h1, 0, (int) d);
            if (borderGap) {
                g.setColor(color);
                g.drawLine(i, (int) d, i, 0);
                g.drawLine(i, (int) d + h1, i, h1);
            }

        }

    }

    // 封裝
    public static ByteArrayInputStream getInputStream() {
        return inputStream;
    }

    public static void setInputStream(ByteArrayInputStream inputStream) {
        ImageCode.inputStream = inputStream;
    }

    public static String getRandString() {
        return randString;
    }

    public static int getNums() {
        return nums;
    }

    public static void setNums(int nums) {
        ImageCode.nums = nums;
    }

    public static int getWidth() {
        return width;
    }

    public static void setWidth(int width) {
        ImageCode.width = width;
    }

    public static int getHeight() {
        return height;
    }

    public static void setHeight(int height) {
        ImageCode.height = height;
    }

    public static int getLeft() {
        return left;
    }

    public static void setLeft(int left) {
        ImageCode.left = left;
    }

    public static int getTop() {
        return top;
    }

    public static void setTop(int top) {
        ImageCode.top = top;
    }

    public static String getCharSet() {
        return charSet;
    }

    public static void setCharSet(String charSet) {
        ImageCode.charSet = charSet;
    }

    public static int getStringMinColor() {
        return stringMinColor;
    }

    public static void setStringMinColor(int stringMinColor) {
        ImageCode.stringMinColor = stringMinColor;
    }

    public static int getStringMaxColor() {
        return stringMaxColor;
    }

    public static void setStringMaxColor(int stringMaxColor) {
        ImageCode.stringMaxColor = stringMaxColor;
    }

    public static int getOtherMinColor() {
        return otherMinColor;
    }

    public static void setOtherMinColor(int otherMinColor) {
        ImageCode.otherMinColor = otherMinColor;
    }

    public static int getOtherMaxColor() {
        return otherMaxColor;
    }

    public static void setOtherMaxColor(int otherMaxColor) {
        ImageCode.otherMaxColor = otherMaxColor;
    }

    public static Color getBackgroundColor() {
        return backgroundColor;
    }

    public static void setBackgroundColor(Color backgroundColor) {
        ImageCode.backgroundColor = backgroundColor;
    }

    public static ImageCode getImageCode() {
        return imageCode;
    }

    public static void setImageCode(ImageCode imageCode) {
        ImageCode.imageCode = imageCode;
    }

    public static void setRandString(String randString) {
        ImageCode.randString = randString;
    }

    public static int getFontSize() {
        return fontSize;
    }

    public static void setFontSize(int fontSize) {
        ImageCode.fontSize = fontSize;
    }

    public static boolean isShear() {
        return isShear;
    }

    public static void setShear(boolean isShear) {
        ImageCode.isShear = isShear;
    }

}

基本思路：

1.用字符集合確定驗證碼顯示的字符；

2.用參數確定各種控制數據；

3.生成一個字符串，賦予一個成員變量，用這個字符串循環繪制在畫布上，給圖片添加干擾線、噪點和文字扭曲等效果；

4.圖片最終賦給一個字節數組輸入流對象。

二、創建TestAction.java

package com.exp.action;

import java.io.ByteArrayInputStream;

import javax.servlet.http.HttpServletResponse;

import com.exp.image.ImageCode;
import com.opensymphony.xwork2.ActionContext;

public class TestAction {
    private String usercode;// 用戶輸入的驗證碼
    private ByteArrayInputStream inputStream;// 圖片輸入流
    private String info;

    /**
     * 登錄
     * 
     * @return
     */
    public String login() {
        // 輸出測試
        System.out.println(ImageCode.getRandString());
        if (ImageCode.getRandString().equals(usercode.toLowerCase())) {
            System.out.println("沒問題");
            info = "驗證碼輸入正確";
        } else {
            System.out.println("不對");
            info = "驗證碼輸入不正確";
        }
        return "test_login_success";
    }

    /**
     * 獲取圖片驗證碼
     * 
     * @return
     */
    public String getimagecode() {
        // 創建圖片驗證碼
        ImageCode.createRandomImage();
        ImageCode.setHeight(21);// 設置高度
        // 輸出測試
        System.out.println(ImageCode.getRandString());
        // 將圖片輸入自字節流賦予inputStream
        this.setInputStream(ImageCode.getInputStream());
        return "test_getimagecode_success";
    }

    // 封裝
    public String getUsercode() {
        return usercode;
    }

    public void setUsercode(String usercode) {
        this.usercode = usercode;
    }

    public ByteArrayInputStream getInputStream() {
        return inputStream;
    }

    public void setInputStream(ByteArrayInputStream inputStream) {
        this.inputStream = inputStream;
    }

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }
}

思路：使用單例模式，獲取驗證碼字節數組輸入流對象，並且聲稱驗證碼字符串。

三、配置struts.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN" "http://struts.apache.org/dtds/struts-2.1.dtd">
<struts>
    <package name="test" namespace="/" extends="struts-default">
        <action name="*_*" class="com.exp.action.{1}Action" method="{2}">
        <result name="test_login_success">/index2.jsp</result>
            <!-- 圖片驗證碼 -->
            <result name="test_getimagecode_success" type="stream">        
                <param name="contentType">image/jpeg</param>        
                <param name="inputName">inputStream</param>        
            </result>  
        </action>
    </package>
</struts>    

思路：規定結果類型為流，設定參數類型為圖片，設定inputName的值為TestAction中的字節數組輸入流對象。

四、設計測試頁面index2.jsp

<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<%@ taglib uri="/struts-tags" prefix="s" %>
<%
    String path = request.getContextPath();
    String basePath = request.getScheme() + "://"
            + request.getServerName() + ":" + request.getServerPort()
            + path + "/";
%>

<!DOCTYPE html>
<html>
<head>
<base href="<%=basePath%>">
<title>My JSP 'index.jsp' starting page</title>
<script type="text/javascript" src="js/jquery-2.1.4.js"></script>
</head>

<body>
    <form action="Test_login" method="post">
    <input id="othertext" placeholder="驗證異步刷新" style="float:left;">
        <input name="usercode" maxlength="6" style="float:left;"> <span style="display:block;float:left;width:80px;height:22px;border:0px solid green;"><img
            id="randimg" src="Test_getimagecode" onclick="changeRandomImage();" style="border:0px solid red;"></span><br>
        <input type="submit" value="OK" style="width:100px;height:21px;float:left;margin:-19px 0 0 10px;">
    </form>
    <div style="width:200px;height:22px;float:left;margin:-18px 0 0 10px;color:red;"><s:property value="info"/></div>
    
    <script type="text/javascript">
    //異步刷新圖片驗證碼
        function changeRandomImage() {
            var imgSrc = $("#randimg");
            var src = imgSrc.attr("src");
            imgSrc.attr("src", changeGetImageUrl(src));
        }
        //時間戳
        //為了使每次生成圖片不一致，即不讓瀏覽器讀緩存，所以需要加上時間戳，讓每次都有新的請求
        function changeGetImageUrl(url) {
            var timestamp = (new Date()).valueOf();
            if ((url.indexOf("&") >= 0)) {
                url = url + "×tamp=" + timestamp;
            } else {
                url = url + "?timestamp=" + timestamp;
            }
            return url;
        }
    </script>
</body>
</html>

思路：點擊圖片進行異步刷新。為了防止每次刷新時頁面讀取緩存導致不變，特意設置一個沒有實際作用的時間戳為參數形成不同的請求，獲得新的結果

五、運行效果