Tesseract-OCR识别验证码

1. 安装Tesseract-OCR，安装后测试下是否安装成功

　aaarticlea/png;base64,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" alt="" />

2. eclipse创建Java项目，再创建包

3. 新建类BaseClass.java, 里面包括通用的一些方法

　

package testNG;

import java.awt.Desktop;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.FileNotFoundException;
import java.io.Writer;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.Locale;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.stream.ImageInputStream;
import javax.imageio.stream.ImageOutputStream;
import javax.xml.crypto.Data;

import org.apache.commons.io.FileUtils;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.xssf.usermodel.XSSFName;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.openqa.selenium.By;
import org.openqa.selenium.OutputType;
import org.openqa.selenium.TakesScreenshot;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.ie.InternetExplorerDriver;
import org.openqa.selenium.remote.DesiredCapabilities;

import com.sun.media.imageio.plugins.tiff.TIFFImageWriteParam;

@SuppressWarnings("unused")

public class BaseClass {
    /***
     * 基础类，包括方法：启动webdriver、获取基础数据、获取测试数据、返回当前时间、写入结果文件、
     * 截图、打开结果文件、去除空格换行及制表符的字符串
     *
     * @param args
     * @throws IOException
     * @throws InterruptedException
     */
    public static WebDriver startBrowser(String browserType){
        /**
          * FunName:        startBrowser
          * Description :   启动浏览器，支持ie/fireFox/chrome
          * @param：                 String browserType
          * @return WebDriver：  driver
          * @Author:        Bingo
          * @Create Date:   2015-07-21
          **/
        WebDriver wd = null;
        if (browserType == "ie"){
             System.setProperty("webdriver.ie.driver", "drivers\\IEDriverServer.exe");//ie驱动路径
             DesiredCapabilities dc = DesiredCapabilities.internetExplorer();
             dc.setCapability(InternetExplorerDriver.INTRODUCE_FLAKINESS_BY_IGNORING_SECURITY_DOMAINS, true);
             //关闭IE浏览器保护模式
             dc.setCapability("ignoreProtectedModeSettings", true);
             wd = new InternetExplorerDriver();
        }else if(browserType == "fireFox"){
            System.setProperty("webdriver.firefox.bin", //firefox的安装路径
                     "D:/Program Files/Mozilla Firefox/firefox.exe");
            wd = new FirefoxDriver();
        }else if(browserType == "chrome"){
            System.setProperty("webdriver.chrome.driver", "drivers\\chromedriver.exe");//驱动路径
            wd = new ChromeDriver();
        }
        return wd;

    }

    //读取测试URL、测试数据文件路径和结果文件路径
    public String getBaseData(String testInfo, String baseDataPath) throws IOException{
        /**
          * FunName:        getBaseData
          * Description :   获取测试URL、测试数据文件路径和结果文件路径
          * @param：                 String testInfo
          * @return String：  返回基础数据字符串；
          * @Author:        Bingo
          * @Create Date:   2015-06-29
          **/
        String testString =  null;
        FileInputStream file = new FileInputStream(baseDataPath);
        @SuppressWarnings("resource")
        XSSFWorkbook wb = new XSSFWorkbook(file);
        XSSFSheet sheet = wb.getSheetAt();
        XSSFRow rowinf = sheet.getRow();
        Cell cell = null;
        switch(testInfo){
            case "inPath"                  : cell = rowinf.getCell();break;
            case "outPath"              : cell = rowinf.getCell();break;
            case "baseURL"              : cell = rowinf.getCell();break;
            case "firefoxPath"          : cell = rowinf.getCell();break;
            case "screenShotDir"          : cell = rowinf.getCell();break;
            case "snapshotDir"          : cell = rowinf.getCell();break;
            case "xiaoWeiIssuerURL"      : cell = rowinf.getCell();break;
            case "Tesseract-OCRPath"      : cell = rowinf.getCell();break;
            default: System.out.println("no testInfo found!");
        }
        cell.setCellType(Cell.CELL_TYPE_STRING);
        testString= cell.getStringCellValue(); 

        return testString;
    }

    //读取信息,被测试方法调用,参数为方法名、列名colNm、文件路径inPath
    public String getData_xlsx(String funNm, String colNm, String inPath) throws FileNotFoundException, IOException{
        /**
          * FunName:        getData_xlsx
          * Description :   读取信息,供被测试方法调用
          * @param：                 String funNm, String colNm, String inPath
          * @return String：  返回测试数据；
          * @Author:        Bingo
          * @Create Date:   2015-06-29
          **/
        String str1 = null;
        FileInputStream file = new FileInputStream(inPath);
        @SuppressWarnings("resource")
        XSSFWorkbook wb = new XSSFWorkbook(file);
        XSSFSheet sheet = null;
        Cell cell = null;
        //根据方法名，读取对应的sheet
        if (funNm == "Login"){
            sheet = wb.getSheetAt();
        } else if (funNm == "QueryApp"){
            sheet = wb.getSheetAt();
        }
        XSSFRow row1 = sheet.getRow();
        //根据不同的列名，读取对应的列
        if(colNm == "orgz"||colNm == "appNo")
            cell = row1.getCell(); 

        else if(colNm == "userId"||colNm == "holName")
            cell = row1.getCell();
        else if(colNm == "pwd"||colNm == "cerType")
            cell = row1.getCell();
        else if(colNm == "cerNo"||colNm == "xiaoWeiUserId")
            cell = row1.getCell();
        else if(colNm == "xiaoWeiUserPwd")
            cell = row1.getCell();
        else System.out.println(nowDate()+" err funcName or colNume");
        cell.setCellType(Cell.CELL_TYPE_STRING);
        str1= cell.getStringCellValue();
        return str1;
    }
    //写入测试结果文件,参数为方法名、是否通过、文件路径和执行时间
    public void outCome_xlsx(String funNm, String outCome, String outPath,String date) throws IOException
    {
        /**
          * FunName:        outCome_xlsx
          * Description :   写入测试结果
          * @param：                 String funNm, String outCome, String outPath,String date
          * @return void：        无返回数据；
          * @Author:        Bingo
          * @Create Date:   2015-06-29
          **/
        FileInputStream file = new FileInputStream(outPath);
        @SuppressWarnings("resource")
        XSSFWorkbook wb = new XSSFWorkbook(file);
        String stname = wb.getSheetName();
        XSSFSheet sheet = wb.getSheetAt();
        int trLength = sheet.getLastRowNum();
        XSSFRow newrow = sheet.createRow((short)(trLength+));
        newrow.createCell().setCellValue(funNm);
        newrow.createCell().setCellValue(outCome);
        newrow.createCell().setCellValue(date);
        FileOutputStream fout = new FileOutputStream(outPath);
        wb.write(fout);
        file.close();
        fout.close();

    }    

//        public File createLogFile(String fileName, String logDir){
//            File file = null;
//
//            return file;
//        }
//        

        //写入日志文件信息,文件名为yyyy-mm-dd.log
        public static File writeLog(String logMsg) throws IOException
        {
            /**
              * FunName:        writeLog
              * Description :   记录日志
              * @param：                 File file, String msg
              * @return file：        返回文件；
              * @Author:        Bingo
              * @Create Date:   2015-07-21
              **/
            //FileInputStream file = new FileInputStream(outPath);
            String logDir = System.getProperty("user.dir")+"\\log\\";
            String time = null;
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");//设置日期格式
            time = sdf.format(new Date()).toString();
            File file = new File(logDir+time+".log");
            if(!file.exists()) {
                file.createNewFile();
            }
            @SuppressWarnings("resource")
            Writer txtWriter = new FileWriter(file,true);
            txtWriter.write(nowDate() +"\t"+logMsg+"\n");
            txtWriter.flush();
            return file;
        }

        public void openOutCome(String outPath){
        /**
          * FunName:        openOutCome
          * Description :   打开测试结果文件
          * @param：                 文件URL
          * @return void：        无返回数据；
          * @Author:        Bingo
          * @Create Date:   2015-06-30
          **/
        Desktop desk=Desktop.getDesktop();
        try
        {
            File file1=new File(outPath);//创建一个java文件系统
            if (!file1.canWrite())//判断文件是否被占用
            {
                desk.open(file1); //调用open（File f）方法打开文件
            }else {
                FileInputStream in=new FileInputStream(file1);
                in.close();
                desk.open(file1);
            }
        }catch(Exception e)
        {
            System.out.println(e.toString());
        }

    }

    public void screenShot(String screenOutDir,WebDriver driver,String funNm) throws InterruptedException{
        /**
          * FunName:        openOutCome
          * Description :   截图
          * @param：                 文件URL
          * @return void：        无返回数据；
          * @Author:        Bingo
          * @Create Date:   2015-06-30
          **/
        //Thread.sleep(3000);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd HHmmss-SSS");
        String time = sdf.format(new Date());

        String fileName = funNm+time +".png";
        try {
             File source_file = ((TakesScreenshot)driver).getScreenshotAs(OutputType.FILE);  // 执行屏幕截图，默认会把截图保存到temp目录

             FileUtils.copyFile(source_file, new File(screenOutDir + "/" + fileName));  // 这里将截图另存到我们需要保存的目录，例如screenshot\20120406 165210-333.png
        } catch (IOException e) {
             e.printStackTrace();
          }
    }

    public  static String replaceBlank(String str) {
        /**
         * 返回STR中去除空格、换行制表符的内容
         *
         */

        String dest = "";
        if (str!=null) {
            Pattern p = Pattern.compile("\\s*|\t|\r|\n");
            Matcher m = p.matcher(str);
            dest = m.replaceAll("");
        }
        return dest;
    }
    //获取当前系统时间
    public static String nowDate(){
        String nowDate = null;
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
        nowDate =df.format(new Date()).toString();
        return nowDate;
    }

    //判断字符串是否纯数字
    public boolean isDigitStr(String s){
        for(int i =; i<s.length()-;i++){
            if(!Character.isDigit(s.charAt(i))){
                return false;
            }
        }
        return true;
    }

    //根据byType及值，返回by，访问方式：driver.findElement(getBy("id","kw"))
    public static WebElement getElement(WebDriver driver,String byType, String byValue){
        WebElement we = null;
        switch(byType){
            case "id": we = driver.findElement(By.id(byValue));break;
            case "xpath": we = driver.findElement(By.xpath(byValue));break;
            case "name": we = driver.findElement(By.name(byValue));break;
            case "className": we = driver.findElement(By.className(byValue));break;
            case "linkText": we = driver.findElement(By.linkText(byValue));break;
            case "cssSelector": we = driver.findElement(By.cssSelector(byValue));break;
            case "tagName": we = driver.findElement(By.tagName(byValue));break;
            case "partialLinkText": we = driver.findElement(By.partialLinkText(byValue));break;
            default:break;

        }
        return we;
    }
    public static void println(Object obj){
        /**
          * FunName:        println
          * Description :   简版打印，代替System.out.print(object)
          * @param：                 object
          * @return String：  none
          * @Author:        Bingoreo
          * @Create Date:   2015-07-15
          **/
        System.out.println(obj);
    }

    public static void print(Object obj){
        /**
          * FunName:        println
          * Description :   简版打印，代替System.out.print(object)
          * @param：                 object
          * @return String：  none
          * @Author:        Bingoreo
          * @Create Date:   2015-07-15
          **/
        System.out.print(obj);

    }

    public static void println(){
        /**
          * FunName:        println
          * Description :   简版打印，代替System.out.println()
          * @param：                 none
          * @return String：  none
          * @Author:        Bingoreo
          * @Create Date:   2015-07-15
          **/
        System.out.println();
    }

    public static void main(String[] args)  {
        // TODO 自动生成的方法存根
    }

}

4. 创建类GetNetImgAndSave.java，获取网页图片并保存本地

package testNG;

import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

import org.apache.commons.io.FileUtils;
import org.openqa.selenium.Dimension;
import org.openqa.selenium.OutputType;
import org.openqa.selenium.Point;
import org.openqa.selenium.TakesScreenshot;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.remote.Augmenter;
/**
 * 类说明：获取网页图片并保存本地
 *
 * @author Bingo
 *
 */
public class GetNetImgAndSave {
    static BaseClass baseclass = new BaseClass();

    public static void main(String[] args) throws IOException {
        // TODO 自动生成的方法存根
        GetNetImgAndSave in = new GetNetImgAndSave();

        try {
            in.inputText();

            baseclass.openOutCome("e://testasdasd.png");
        } catch (InterruptedException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
    }

public static void snapshot2(WebDriver drivername, String filename, String baseDataPath)
{
    //截图
    try {
            WebDriver augmentedDriver = new Augmenter().augment(drivername);
            File screenshot = ((TakesScreenshot) augmentedDriver).getScreenshotAs(OutputType.FILE);
            String snapshotDir = baseclass.getBaseData("snapshotDir", baseDataPath);
            File file = new File(snapshotDir+filename);
            FileUtils.copyFile(screenshot, file);
      } catch (IOException e) {
          // TODO Auto-generated catch block
          BaseClass.println(BaseClass.nowDate()+" Can't save screenshot");
          e.printStackTrace();
      }
      finally
      {
          BaseClass.println(BaseClass.nowDate()+" screen shot finished");
      }
    }

    public static byte[] takeScreenshot(WebDriver driver) throws IOException {
        WebDriver augmentedDriver = new Augmenter().augment(driver);
    return ((TakesScreenshot) augmentedDriver).getScreenshotAs(OutputType.BYTES);
        //TakesScreenshot takesScreenshot = (TakesScreenshot) driver;
        //return takesScreenshot.getScreenshotAs(OutputType.BYTES);
        }

     public static BufferedImage createElementImage(WebDriver driver,WebElement webElement)
                throws IOException, InterruptedException {
                // 获得webElement的位置和大小。
                Point location = webElement.getLocation();
                Dimension size = webElement.getSize();
                // 创建全屏截图。
                BufferedImage originalImage =
                ImageIO.read(new ByteArrayInputStream(takeScreenshot(driver)));
                // 截取webElement所在位置的子图。
                BufferedImage croppedImage = originalImage.getSubimage(
                location.getX(),
                location.getY(),
                size.getWidth(),
                size.getHeight());
                Thread.sleep(3000);
                return croppedImage;
                }
    public void inputText() throws InterruptedException, IOException{
        /***
         *
         *
         */
        String baseDataPath = "E:/workspace/1506/testNG/testdata/testData.xlsx";
        String firefoxPath;
        String testURL =  baseclass.getBaseData("testURL", baseDataPath);
        String OCRPath = baseclass.getBaseData("Tesseract-OCRPath", baseDataPath);
        try {
            firefoxPath = baseclass.getBaseData("firefoxPath",baseDataPath);

            System.setProperty("webdriver.firefox.bin",firefoxPath);
            WebDriver driver = new FirefoxDriver();
            driver.get(testURL);
            //driver.findElement(By.id("codeImg")).click();
            //driver.findElement(By.id("randCode")).clear();
            WebElement keyWord;
            try{
               keyWord = BaseClass.getElement(driver,"id","codeImg");
               if(keyWord!=null){
                   String src =  keyWord.getAttribute("src");
                   BaseClass.println(BaseClass.nowDate()+"  验证码地址 ====="+src);
                   if(src!=null && !"".equals(src)){
                       snapshot2(driver,"1111111111.png",baseDataPath);
                       BufferedImage inputbig = createElementImage(driver,keyWord);
                       ImageIO.write(inputbig, "png", new File("c://testasdasd.png"));
                       OCRTif ocr = new OCRTif();

                       String key= ocr.recognizeText(new File("c://testasdasd.png"), "png", OCRPath);
                       //验证码输入框
                       BaseClass.println(BaseClass.nowDate()+" +++++\nkey:\n"+key+"\n+++++");
                       //keyWord = driver.findElement(By.id("randCode"));
                       //keyWord.clear();
                       BaseClass.getElement(driver,"id","randCode").sendKeys(key);
                       //keyWord.sendKeys(key);
                       Thread.sleep(3000);

                   }  

               }
           }catch(Exception e){
               e.printStackTrace();
           }
        } catch (IOException e1) {
            // TODO 自动生成的 catch 块
            e1.printStackTrace();
        }
       }
    }

5. 创建类ImageConvertGif.java, 用于转换图片类型，并返回文件实例

package testNG;
/***
 * 将指定类型的图像文件转换为tif
 *
 */
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Iterator;
import java.util.Locale;  

import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.stream.ImageInputStream;
import javax.imageio.stream.ImageOutputStream;  

import com.sun.media.imageio.plugins.tiff.TIFFImageWriteParam;

public class ImageConverGif{
public static File createImage(File imageFile, String imageFormat) {
    File tempFile = null;
    try {
        Iterator<ImageReader> readers = ImageIO.getImageReadersByFormatName(imageFormat);
        ImageReader reader = readers.next();  

        ImageInputStream iis = ImageIO.createImageInputStream(imageFile);
        reader.setInput(iis);
        //Read the stream metadata
        IIOMetadata streamMetadata = reader.getStreamMetadata();  

        //Set up the writeParam
        TIFFImageWriteParam tiffWriteParam = new TIFFImageWriteParam(Locale.CHINESE);
        tiffWriteParam.setCompressionMode(ImageWriteParam.MODE_DISABLED);  

        //Get tif
        Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName("tiff");
        ImageWriter writer = writers.next();  

        BufferedImage bi = reader.read(0);
        IIOImage image = new IIOImage(bi,null,reader.getImageMetadata(0));
        tempFile = tempImageFile(imageFile);
        ImageOutputStream ios = ImageIO.createImageOutputStream(tempFile);
        writer.setOutput(ios);
        writer.write(streamMetadata, image, tiffWriteParam);
        ios.close();  

        writer.dispose();
        reader.dispose();  

    } catch (IOException e) {
        e.printStackTrace();
    }
    return tempFile;
}  

private static File tempImageFile(File imageFile) {
    String path = imageFile.getPath();
    StringBuffer strB = new StringBuffer(path);
    strB.insert(path.lastIndexOf('.'),0);
    return new File(strB.toString().replaceFirst("(?<=//.)(//w+)$", "tif"));
}  

} 

6. 创建类OCRTif.java，用于识别本地验证码，并返回验证码字符串

package testNG;

//import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;  

//import javax.imageio.ImageIO;

//import org.apache.james.mime4j.util.ContentUtil;
/***
 *
 *
 * @author tuanFu
 *
 */

//OCR识别图片验证码，
public class OCRTif {
    //private final String LANG_OPTION = "-l";  //小写英文字母l（L），并非数字1
    private final String LS = System.getProperty("line.separator");
    //private String tessPath = "E:/Program Files/Tesseract-OCR";  //Tesseract-OCR 安装路径
    //private String tessPath = new File("tesseract").getAbsolutePath();
    //tessPath为Tesseract-OCR安装地址
    public String recognizeText(File imageFile,String imageFormat, String tessPath)throws Exception{  

        File tempImage = ImageConverGif.createImage(imageFile,imageFormat);
        File outputFile = new File(imageFile.getParentFile(),"output");
        StringBuffer strB = new StringBuffer();
        List<String> cmd = new ArrayList<String>();
        cmd.add(tessPath+"//tesseract");
        cmd.add("");
        cmd.add(outputFile.getName());
        //cmd.add(LANG_OPTION);
        //cmd.add("chi_sim");
        //cmd.add("eng");  

        ProcessBuilder pb = new ProcessBuilder();
        pb.directory(imageFile.getParentFile());  

        cmd.set(1, tempImage.getName());
        pb.command(cmd);
        pb.redirectErrorStream(true);  

        Process process = pb.start();
        //tesseract.exe 1.jpg 1 -l chi_sim
        int w = process.waitFor();    

        //删除临时正在工作文件
        tempImage.delete();  

        if(w==0){
            BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(outputFile.getAbsolutePath()+".txt"),"UTF-8"));  

            String str;
            while((str = in.readLine())!=null){
                strB.append(str).append(LS);
            }
            in.close();
        }else{
            String msg;
            switch(w){
                case 1:
                    msg = "Errors accessing files.There may be spaces in your image's filename.";
                    break;
                case 29:
                    msg = "Cannot recongnize the image or its selected region.";
                    break;
                case 31:
                    msg = "Unsupported image format.";
                    break;
                default:
                    msg = "Errors occurred.";
            }
            tempImage.delete();
            throw new RuntimeException(msg);
        }
        new File(outputFile.getAbsolutePath()+".txt").delete();
        Thread.sleep(3000);
        return strB.toString();
    }  

    /**文件转换
    public static void converter(File imgFile,String format,File formatFile)
            throws IOException{
        BufferedImage bIMG =ImageIO.read(imgFile);
        ImageIO.write(bIMG, format, formatFile);
    }
    **/
    public static void main(String[] args) throws IOException {  

        String path = "http:...//captcha.png";
        //converter(new File(path),"jpeg", new File("d:\\psb2.jpg"));
        String tessPath = "E:/Program Files/Tesseract-OCR";//Tesseract-OCR install path
        try {
            String valCode = new OCRTif().recognizeText(new File(path), "png",tessPath);  //png为当前文件类型
            System.out.println(valCode);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
} 

7. 创建类XiaoWeiLogin.java，验证效果。

package testNG;

import java.awt.image.BufferedImage;

import javax.imageio.ImageIO;

import java.io.File;
import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.annotations.Test;

public class XiaoWeiLogin
{    

    @Test
    public static WebDriver xiaoWeiLogin() throws Exception
    {
        String failMSG = "登录失败";
        String tag = null;//用于控制登录失败后，重新登录
        String baseDataPath = "E:\\workspace\\1506\\testNG\\testdata\\testData.xlsx";
        BaseClass data = new BaseClass();
        String xiaoWeiIssuerURL = data.getBaseData("xiaoWeiIssuerURL", baseDataPath);
        String inPath = data.getBaseData("inPath", baseDataPath);
        String outPath = data.getBaseData("outPath", baseDataPath);
        String TesseractOCRPath = data.getBaseData("Tesseract-OCRPath", baseDataPath);
        String userId = data.getData_xlsx("Login", "xiaoWeiUserId", inPath);
        String pwd = data.getData_xlsx("Login", "xiaoWeiUserPwd", inPath);
        String firefoxPath= data.getBaseData("firefoxPath",baseDataPath);
        String userIdXPath = "//*[@id='j_username']";
        String pwdXPath = "//*[@id='j_password']";
        String codeXpath = "//*[@id='codeImg']";
        String checkCode ="//*[@id='checkCode']";

        System.setProperty("webdriver.firefox.bin",firefoxPath);
        WebDriver driver = new FirefoxDriver();
        driver.get(xiaoWeiIssuerURL);
        driver.manage().window().maximize();
        while (tag == null)
        {    //刷新
            driver.navigate().refresh();
            BaseClass.getElement(driver, "xpath", userIdXPath).clear();
            BaseClass.getElement(driver, "xpath", userIdXPath).sendKeys(userId);
            driver.findElement(By.xpath(pwdXPath)).clear();
            driver.findElement(By.xpath(pwdXPath)).sendKeys(pwd);
            WebElement keyWord = driver.findElement(By.xpath(codeXpath));
            if(keyWord!=null)
               {
                   String src =  keyWord.getAttribute("src");
                   BaseClass.println(BaseClass.nowDate()+"  验证码地址 ="+src);
                   if(src!=null && !"".equals(src))
                   {
                       //截屏并保存本地
                       GetNetImgAndSave.snapshot2(driver,"1111111111.png",baseDataPath);
                       BufferedImage bi = GetNetImgAndSave.createElementImage(driver,keyWord);
                       ImageIO.write(bi, "png", new File("e://testasdasd.png"));
                       //Tesseract-OCR识别本地验证码，并获取结果
                       OCRTif ocr = new OCRTif();
                       String key= ocr.recognizeText(new File("e://testasdasd.png"),
                               "png", TesseractOCRPath);
                       //去除空格、换行、制表符等
                       String noBlankStr = BaseClass.replaceBlank(key);
                       //验证码输入框
                       BaseClass.println(BaseClass.nowDate()+"  ==========key:"+noBlankStr+"==========");
                       BaseClass.println(BaseClass.nowDate()+"  ==========获取到的验证码长度："+noBlankStr.length()+
                               "==========");

                       if (data.isDigitStr(noBlankStr)){
                           if (noBlankStr.length()==4)
                           {
                               BaseClass.println(BaseClass.nowDate()+"  验证码长度正确，尝试登录");
                               driver.findElement(By.xpath(checkCode)).clear();
                               driver.findElement(By.xpath(checkCode)).sendKeys(noBlankStr);
                               driver.findElement(By.xpath("//*[@id='loginForm']/"
                                          + "table/tbody/tr/td[2]/table[3]/tbody/tr/td[2]/img")).click();
                               driver.manage().timeouts().implicitlyWait(3, TimeUnit.SECONDS);
                               try {
                                       driver.findElement(By.xpath("//*[contains(.,'"
                                           + failMSG + "')]"));
                                       System.out.println(BaseClass.nowDate()+"  验证码错误，重新登录");
                                       BaseClass.writeLog("验证码错误，重新登录");
                                       continue;
                                       //driver.close();
                               } catch (Exception e) {
                                   System.out.println(BaseClass.nowDate()+"  登录成功");
                                   BaseClass.writeLog("login success！");
                                   data.screenShot(data.getBaseData("screenShotDir", baseDataPath),
                                                  driver, "xiaoWeiLogin");
                                   driver.close();
                                   tag = "success";
                                   String nowDate = BaseClass.nowDate();
                                   data.outCome_xlsx("xiaoWeiLogin", "pass", outPath, nowDate);
                                   data.openOutCome(outPath);
                                   break;
                               }

                           }else{
                               BaseClass.println(BaseClass.nowDate()+"  验证码长度错误，重新登录");
                               BaseClass.writeLog("验证码长度错误，重新登录");
                               //driver.close();
                           }
                       }else{
                               BaseClass.println(BaseClass.nowDate()+"  验证码非纯数字，重新登录");
                            BaseClass.writeLog("验证码非纯数字，重新登录");
                               //driver.close();
                    }

                 }
            }
        }
        return driver;
    }

    public static void main(String[] args) throws Exception
    {
        // TODO 自动生成的方法存根

        XiaoWeiLogin.xiaoWeiLogin();

    }
}

日志打印如下：

aaarticlea/png;base64,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" alt="" />

8. 说明。

　　本次只是识别纯数字验证码，识别成功率在50%左右，如果需要识别特定语言的验证码，需要加入语言包，并在代码中加上语言参数

9. 参考资料：

　　http://songpo-ath-taobao-com.iteye.com/blog/1664226