Java 如何更新印度铁路站点中添加的PNR Capcha

我在Google Play上有一个PNR查询应用程序。它工作得很好。但最近印度Railwys在其PNR查询部分添加了captcha，因此我无法向服务器传递正确的数据以获得正确的响应。如何在我的应用程序中以imageview的形式添加此验证码，并要求用户输入验证码详细信息，以便我可以发送正确的数据并获得正确的响应

这是我之前使用的PnrCheck.java。请说明此处应进行哪些修改

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

import org.apache.http.Header;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.HttpVersion;
import org.apache.http.entity.InputStreamEntity;
import org.apache.http.impl.DefaultHttpClientConnection;
import org.apache.http.message.BasicHttpEntityEnclosingRequest;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import org.apache.http.protocol.BasicHttpContext;
import org.apache.http.protocol.BasicHttpProcessor;
import org.apache.http.protocol.ExecutionContext;
import org.apache.http.protocol.HttpContext;
import org.apache.http.protocol.HttpRequestExecutor;
import org.apache.http.protocol.RequestConnControl;
import org.apache.http.protocol.RequestContent;
import org.apache.http.protocol.RequestExpectContinue;
import org.apache.http.protocol.RequestTargetHost;
import org.apache.http.protocol.RequestUserAgent;
import org.apache.http.util.EntityUtils;

public class PNRStatusCheck {
    public static void main(String args[]) {
        try {
            String pnr1 = "1154177041";
            String reqStr = "lccp_pnrno1=" + pnr1 + "&submitpnr=Get+Status";
            PNRStatusCheck check = new PNRStatusCheck();
            StringBuffer data = check.getPNRResponse(reqStr, "http://www.indianrail.gov.in/cgi_bin/inet_pnrstat_cgi.cgi");
            if(data != null) {
                @SuppressWarnings("unused")
                PNRStatus pnr = check.parseHtml(data);
            }
        } catch(Exception e) {
            e.printStackTrace();
        }
    }

    public StringBuffer getPNRResponse(String reqStr, String urlAddr) throws Exception {
        String urlHost = null;
        int port;
        String method = null;
        try {
            URL url = new URL(urlAddr);
            urlHost = url.getHost();
            port = url.getPort();
            method = url.getFile();

            // validate port
            if(port == -1) {
                port = url.getDefaultPort();
            }
        } catch(Exception e) {
            e.printStackTrace();
            throw new Exception(e);
        }

        HttpParams params = new BasicHttpParams();
        HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
        HttpProtocolParams.setContentCharset(params, "UTF-8");
        HttpProtocolParams.setUserAgent(params, "HttpComponents/1.1");
        HttpProtocolParams.setUseExpectContinue(params, true);

        BasicHttpProcessor httpproc = new BasicHttpProcessor();
        // Required protocol interceptors
        httpproc.addInterceptor(new RequestContent());
        httpproc.addInterceptor(new RequestTargetHost());
        // Recommended protocol interceptors
        httpproc.addInterceptor(new RequestConnControl());
        httpproc.addInterceptor(new RequestUserAgent());
        httpproc.addInterceptor(new RequestExpectContinue());

        HttpRequestExecutor httpexecutor = new HttpRequestExecutor();
        HttpContext context = new BasicHttpContext(null);
        HttpHost host = new HttpHost(urlHost, port);
        DefaultHttpClientConnection conn = new DefaultHttpClientConnection();

        context.setAttribute(ExecutionContext.HTTP_CONNECTION, conn);
        context.setAttribute(ExecutionContext.HTTP_TARGET_HOST, host);
        @SuppressWarnings("unused")
        String resData = null;
        @SuppressWarnings("unused")
        String statusStr = null;
        StringBuffer buff = new StringBuffer();
        try {
            String REQ_METHOD = method;
            String[] targets = { REQ_METHOD };

            for (int i = 0; i < targets.length; i++) {
                if (!conn.isOpen()) {
                    Socket socket = new Socket(host.getHostName(), host.getPort());
                    conn.bind(socket, params);
                }
                BasicHttpEntityEnclosingRequest req = new BasicHttpEntityEnclosingRequest("POST", targets[i]);
                req.setEntity(new InputStreamEntity(new ByteArrayInputStream(reqStr.toString().getBytes()), reqStr.length()));
                req.setHeader("Content-Type", "application/x-www-form-urlencoded");
                req.setHeader("User-Agent", "Mozilla/5.0 (Windows NT 5.1) AppleWebKit/535.7 (KHTML, like Gecko) Chrome/16.0.912.75 Safari/535.7");
                req.setHeader("Cache-Control", "max-age=0");
                req.setHeader("Connection", "keep-alive");
                req.setHeader("Origin", "http://www.indianrail.gov.in");
                req.setHeader("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
                req.setHeader("Referer", "http://www.indianrail.gov.in/pnr_Enq.html");
                //req.setHeader("Accept-Encoding", "gzip,deflate,sdch");
                req.setHeader("Accept-Language", "en-US,en;q=0.8");
                req.setHeader("Accept-Charset", "ISO-8859-1,utf-8;q=0.7,*;q=0.3");


                httpexecutor.preProcess(req, httpproc, context);

                HttpResponse response = httpexecutor.execute(req, conn, context);
                response.setParams(params);
                httpexecutor.postProcess(response, httpproc, context);

                Header[] headers = response.getAllHeaders();
                for(int j=0; j<headers.length; j++) {
                    if(headers[j].getName().equalsIgnoreCase("ERROR_MSG")) {
                        resData = EntityUtils.toString(response.getEntity());
                    } 
                }
                statusStr = response.getStatusLine().toString();
                InputStream in = response.getEntity().getContent();
                BufferedReader reader = null;
                if(in != null) {
                    reader = new BufferedReader(new InputStreamReader(in));
                }

                String line = null;
                while((line = reader.readLine()) != null) {
                    buff.append(line + "\n");
                }
                try {
                    in.close();
                } catch (Exception e) {}
            }
        } catch (Exception e) {
            throw new Exception(e);
        } finally {
            try {
                conn.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return buff;
    }

    public PNRStatus parseHtml(StringBuffer data) throws Exception {
        BufferedReader reader = null;
        if(data != null) {
            reader = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(data.toString().getBytes())));
        } else {
            return null;
        }

        String line = null;
        TrainDetails trainDetails = new TrainDetails();
        List<PassengerDetails> passDetailsList = new ArrayList<PassengerDetails>();
        PassengerDetails passDetails = null;
        int i = 0;
        while ((line = reader.readLine()) != null) {
            if(line.startsWith("<TD") && line.contains("table_border_both")) {
                line = line.replace("<B>", "");
                line = line.substring(line.indexOf("\">")+2, line.indexOf("</")).trim();

                if(line.contains("CHART")) {
                    trainDetails.setChatStatus(line);
                    break;
                }
                if(i > 7) {//Passenger Details
                    if(passDetails == null) {
                        passDetails = new PassengerDetails();
                    }
                    switch(i) {
                    case 8 :
                        passDetails.setName(line);
                        break;
                    case 9 :
                        passDetails.setBookingStatus(line.replace(" ", ""));
                        break;
                    case 10 :
                        passDetails.setCurrentStatus(line.replace(" ", ""));
                        i = 7;
                        break;
                    }
                    if(i == 7 ) {
                        passDetailsList.add(passDetails);
                        passDetails = null;
                    }

                } else { // Train details
                    switch(i){
                    case 0 :
                            trainDetails.setNumber(line);
                            break;
                    case 1 :
                            trainDetails.setName(line);
                            break;
                    case 2 :
                            trainDetails.setBoardingDate(line);
                            break;
                    case 3 :
                            trainDetails.setFrom(line);
                            break;
                    case 4 :
                            trainDetails.setTo(line);
                            break;
                    case 5 :
                            trainDetails.setReservedUpto(line);
                            break;
                    case 6 :
                            trainDetails.setBoardingPoint(line);
                            break;
                    case 7 :
                            trainDetails.setReservedType(line);
                            break;
                    default :
                        break;
                    }
                }
                i++;
            }
        }

        if(trainDetails.getNumber() != null) {
            PNRStatus pnrStatus = new PNRStatus();
            pnrStatus.setTrainDetails(trainDetails);
            pnrStatus.setPassengerDetails(passDetailsList);
            return pnrStatus;
        } else {
            return null;
        }
    }

}

导入java.io.BufferedReader；
导入java.io.ByteArrayInputStream；
导入java.io.IOException；
导入java.io.InputStream；
导入java.io.InputStreamReader；
导入java.net.Socket；
导入java.net.URL；
导入java.util.ArrayList；
导入java.util.List；
导入org.apache.http.Header；
导入org.apache.http.HttpHost；
导入org.apache.http.HttpResponse；
导入org.apache.http.HttpVersion；
导入org.apache.http.entity.InputStreamEntity；
导入org.apache.http.impl.DefaultHttpClientConnection；
导入org.apache.http.message.BasicHttpEntityEnclosingRequest；
导入org.apache.http.params.BasicHttpParams；
导入org.apache.http.params.HttpParams；
导入org.apache.http.params.HttpProtocolParams；
导入org.apache.http.protocol.BasicHttpContext；
导入org.apache.http.protocol.BasicHttpProcessor；
导入org.apache.http.protocol.ExecutionContext；
导入org.apache.http.protocol.HttpContext；
导入org.apache.http.protocol.HttpRequestExecutor；
导入org.apache.http.protocol.RequestConControl；
导入org.apache.http.protocol.RequestContent；
导入org.apache.http.protocol.RequestExpectContinue；
导入org.apache.http.protocol.RequestTargetHost；
导入org.apache.http.protocol.RequestUserAgent；
导入org.apache.http.util.EntityUtils；
公共类PNRStatusCheck{
公共静态void main（字符串参数[]）{
试一试{
字符串pnr1=“1154177041”；
String reqStr=“lccp\u pnrno1=“+pnr1+”&submitpnr=Get+Status”；
PNRStatusCheck check=新的PNRStatusCheck（）；
StringBuffer data=check.getPNRResponse（reqStr，“http://www.indianrail.gov.in/cgi_bin/inet_pnrstat_cgi.cgi");
如果（数据！=null）{
@抑制警告（“未使用”）
PNRStatus pnr=check.parseHtml（数据）；
}
}捕获（例外e）{
e、 printStackTrace（）；
}
}
publicstringbuffergetpnrresponse（stringreqstr，stringurladdr）引发异常{
字符串urlHost=null；
国际港口；
字符串方法=null；
试一试{
URL=新URL（urlAddr）；
urlHost=url.getHost（）；
port=url.getPort（）；
方法=url.getFile（）；
//验证端口
如果（端口==-1）{
port=url.getDefaultPort（）；
}
}捕获（例外e）{
e、 printStackTrace（）；
抛出新异常（e）；
}
HttpParams params=新的BasicHttpParams（）；
HttpProtocolParams.setVersion（params，HttpVersion.HTTP_1_1）；
HttpProtocolParams.setContentCharset（参数，“UTF-8”）；
setUserAgent（params，“HttpComponents/1.1”）；
HttpProtocolParams.setUseExpectContinue（params，true）；
BasicHttpProcessor httpproc=新的BasicHttpProcessor（）；
//所需的协议拦截器
httpproc.addInterceptor（新的RequestContent（））；
httpproc.addInterceptor（新的RequestTargetHost（））；
//推荐的协议拦截器
httpproc.addInterceptor（新的RequestConnControl（））；
httpproc.addInterceptor（新的RequestUserAgent（））；
httpproc.addInterceptor（新请求ExpectContinue（））；
HttpRequestExecutor httpexecutor=新的HttpRequestExecutor（）；
HttpContext=新的BasicHttpContext（null）；
HttpHost主机=新的HttpHost（urlHost，端口）；
DefaultHttpClientConnection conn=新的DefaultHttpClientConnection（）；
setAttribute（ExecutionContext.HTTP_连接，conn）；
setAttribute（ExecutionContext.HTTP_TARGET_HOST，HOST）；
@抑制警告（“未使用”）
字符串resData=null；
@抑制警告（“未使用”）
字符串statusStr=null；
StringBuffer buff=新的StringBuffer（）；
试一试{
字符串请求\方法=方法；
String[]targets={REQ_METHOD}；
for（int i=0；i//Generates the captcha function that draws the captcha  
function DrawCaptcha()
    {       
    var a = Math.ceil(Math.random() * 9)+ '';
    var b = Math.ceil(Math.random() * 9)+ '';      
    var c = Math.ceil(Math.random() * 9)+ ''; 
    var d = Math.ceil(Math.random() * 9)+ ''; 
    var e = Math.ceil(Math.random() * 9)+ ''; 

    var code = a + b + c + d + e;
    document.getElementById("txtCaptcha").value = code;
    document.getElementById("txtCaptchaDiv").innerHTML = code; 
}

//Function to checking the form inputs:

function checkform(theform){
    var why = "";

    if(theform.txtInput.value == ""){
    why += "- Security code should not be empty.\n";
    }
    if(theform.txtInput.value != ""){
        if(ValidCaptcha(theform.txtInput.value) == false){ //here validating the captcha
            why += "- Security code did not match.\n";
        }
    }
    if(why != ""){
        alert(why);
        return false;
    }
}

// Validate the Entered input aganist the generated security code function  
function ValidCaptcha(){
    var str1 = removeSpaces(document.getElementById('txtCaptcha').value);
    var str2 = removeSpaces(document.getElementById('txtInput').value);
    if (str1 == str2){
        return true;   
    }else{
        return false;
    }
}

// Remove the spaces from the entered and generated code
function removeSpaces(string){
    return string.split(' ').join('');
}

private static final String FORM_TARGET = "http://www.indianrail.gov.in/cgi_bin/inet_pnstat_cgi.cgi";
private static final String INPUT_PNR = "lccp_pnrno1";
private static final String INPUT_CAPTCHA = "lccp_capinp_val";
private static final String INPUT_CAPTCHA_HIDDEN = "lccp_cap_val";

private void getHtml(String userPnr) {
    MultipartEntityBuilder builder = MultipartEntityBuilder.create();
    builder.addTextBody(INPUT_PNR, userPnr); // users PNR code
    builder.addTextBody(INPUT_CAPTCHA, "123456");
    builder.addTextBody("submit", "Get Status");
    builder.addTextBody(INPUT_CAPTCHA_HIDDEN, "123456"); // values don't
                                                            // matter as
                                                            // long as they
                                                            // are the same

    HttpEntity entity = builder.build();

    HttpPost httpPost = new HttpPost(FORM_TARGET);
    httpPost.setEntity(entity);

    HttpClient client = new DefaultHttpClient();

    HttpResponse response = null;
    String htmlString = "";
    try {
        response = client.execute(httpPost);
        htmlString = convertStreamToString(response.getEntity().getContent());
                // now you can parse this string to get data you require.
    } catch (Exception letsIgnoreItForNow) {
    }
}

private static String convertStreamToString(InputStream is) {
    BufferedReader reader = new BufferedReader(new InputStreamReader(is));
    StringBuilder sb = new StringBuilder();

    String line = null;
    try {
        while ((line = reader.readLine()) != null) {
            sb.append(line);
        }
    } catch (IOException ignoredOnceMore) {
    } finally {
        try {
            is.close();
        } catch (IOException manyIgnoredExceptions) {
        }
    }

    return sb.toString();
}