java实现腾讯ocr图片识别接口调用

package com.weaver.formmodel.integration.ocr;

import java.util.random;

import javax.crypto.mac;

import javax.crypto.spec.secretkeyspec;

import weaver.general.base64;

public class signutil {

  /**

  * 生成 authorization 签名字段

  *

  * @param appid

  * @param secretid

  * @param secretkey

  * @param bucketname

  * @param expired

  * @return 签名字符串

  * @throws exception

  */

  public static string appsign( long appid, string secretid, string secretkey,

   string bucketname, long expired) throws exception {

  long now = system.currenttimemillis() / 1000 ;

  int rdm = math.abs( new random().nextint());

  string plaintext = string.format( "a=%d&b=%s&k=%s&t=%d&e=%d&r=%d" ,

   appid, bucketname, secretid, now, now + expired, rdm);

  byte [] hmacdigest = hmacsha1(plaintext, secretkey);

  byte [] signcontent = new byte [hmacdigest.length

   + plaintext.getbytes().length];

  system.arraycopy(hmacdigest, 0 , signcontent, 0 , hmacdigest.length);

  system.arraycopy(plaintext.getbytes(), 0 , signcontent,

   hmacdigest.length, plaintext.getbytes().length);

  return base64encode(signcontent);

  }

  /**

  * 生成 base64 编码

  *

  * @param binarydata

  * @return

  */

  public static string base64encode( byte [] binarydata) {

  string encodedstr = new string(base64.encode(binarydata));

  return encodedstr;

  }

  /**

  * 生成 hmacsha1 签名

  *

  * @param binarydata

  * @param key

  * @return

  * @throws exception

  */

  public static byte [] hmacsha1( byte [] binarydata, string key)

   throws exception {

  mac mac = mac.getinstance( "hmacsha1" );

  secretkeyspec secretkey = new secretkeyspec(key.getbytes(), "hmacsha1" );

  mac.init(secretkey);

  byte [] hmacsha1digest = mac.dofinal(binarydata);

  return hmacsha1digest;

  }

  /**

  * 生成 hmacsha1 签名

  *

  * @param plaintext

  * @param key

  * @return

  * @throws exception

  */

  public static byte [] hmacsha1(string plaintext, string key)

   throws exception {

  return hmacsha1(plaintext.getbytes(), key);

  }

}

package weaver.general;

import java.io.bufferedinputstream;

import java.io.bufferedoutputstream;

import java.io.bufferedreader;

import java.io.bufferedwriter;

import java.io.bytearrayoutputstream;

import java.io.chararraywriter;

import java.io.file;

import java.io.fileinputstream;

import java.io.fileoutputstream;

import java.io.filereader;

import java.io.filewriter;

import java.io.inputstream;

import java.io.outputstream;

import java.io.reader;

import java.io.writer;

/**

  * provides encoding of raw bytes to base64-encoded characters, and decoding of

  * base64 characters to raw bytes. date: 06 august 1998 modified: 14 february

  * 2000 modified: 22 september 2000

  *

  * @author kevin kelley (kelley@ruralnet.net)

  * @version 1.3

  */

public class base64 {

  /**

  * returns an array of base64-encoded characters to represent the passed

  * data array.

  *

  * @param data

  *      the array of bytes to encode

  * @return base64-coded character array.

  */

  public static char [] encode( byte [] data) {

  char [] out = new char [((data.length + 2 ) / 3 ) * 4 ];

  //

  // 3 bytes encode to 4 chars. output is always an even

  // multiple of 4 characters.

  //

  for ( int i = 0 , index = 0 ; i < data.length; i += 3 , index += 4 ) {

   boolean quad = false ;

   boolean trip = false ;

   int val = ( 0xff & data[i]);

   val <<= 8 ;

   if ((i + 1 ) < data.length) {

   val |= ( 0xff & data[i + 1 ]);

   trip = true ;

   }

   val <<= 8 ;

   if ((i + 2 ) < data.length) {

   val |= ( 0xff & data[i + 2 ]);

   quad = true ;

   }

   out[index + 3 ] = alphabet[(quad ? (val & 0x3f ) : 64 )];

   val >>= 6 ;

   out[index + 2 ] = alphabet[(trip ? (val & 0x3f ) : 64 )];

   val >>= 6 ;

   out[index + 1 ] = alphabet[val & 0x3f ];

   val >>= 6 ;

   out[index + 0 ] = alphabet[val & 0x3f ];

  }

  return out;

  }

  /**

  * decodes a base-64 encoded stream to recover the original data. white

  * space before and after will be trimmed away, but no other manipulation of

  * the input will be performed.

  *

  * as of version 1.2 this method will properly handle input containing junk

  * characters (newlines and the like) rather than throwing an error. it does

  * this by pre-parsing the input and generating from that a count of valid

  * input characters.

  **/

  public static byte [] decode( char [] data) {

  // as our input could contain non-base64 data (newlines,

  // whitespace of any sort, whatever) we must first adjust

  // our count of usable data so that...

  // (a) we don't misallocate the output array, and

  // (b) think that we miscalculated our data length

  // just because of extraneous throw-away junk

  int templen = data.length;

  for ( int ix = 0 ; ix < data.length; ix++) {

   if ((data[ix] > 255 ) || codes[data[ix]] < 0 )

   --templen; // ignore non-valid chars and padding

  }

  // calculate required length:

  // -- 3 bytes for every 4 valid base64 chars

  // -- plus 2 bytes if there are 3 extra base64 chars,

  // or plus 1 byte if there are 2 extra.

  int len = (templen / 4 ) * 3 ;

  if ((templen % 4 ) == 3 )

   len += 2 ;

  if ((templen % 4 ) == 2 )

   len += 1 ;

  byte [] out = new byte [len];

  int shift = 0 ; // # of excess bits stored in accum

  int accum = 0 ; // excess bits

  int index = 0 ;

  // we now go through the entire array (not using the 'templen' value)

  for ( int ix = 0 ; ix < data.length; ix++) {

   int value = (data[ix] > 255 ) ? - 1 : codes[data[ix]];

   if (value >= 0 ) // skip over non-code

   {

   accum <<= 6 ; // bits shift up by 6 each time thru

   shift += 6 ; // loop, with new bits being put in

   accum |= value; // at the bottom.

   if (shift >= 8 ) // whenever there are 8 or more shifted in,

   {

    shift -= 8 ; // write them out (from the top, leaving any

    out[index++] = // excess at the bottom for next iteration.

    ( byte ) ((accum >> shift) & 0xff );

   }

   }

   // we will also have skipped processing a padding null byte ('=')

   // here;

   // these are used only for padding to an even length and do not

   // legally

   // occur as encoded data. for this reason we can ignore the fact

   // that

   // no index++ operation occurs in that special case: the out[] array

   // is

   // initialized to all-zero bytes to start with and that works to our

   // advantage in this combination.

  }

  // if there is still something wrong we just have to throw up now!

  if (index != out.length) {

   throw new error( "miscalculated data length (wrote " + index

    + " instead of " + out.length + ")" );

  }

  return out;

  }

  //

  // code characters for values 0..63

  //

  private static char [] alphabet = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789+/="

   .tochararray();

  //

  // lookup table for converting base64 characters to value in range 0..63

  //

  private static byte [] codes = new byte [ 256 ];

  static {

  for ( int i = 0 ; i < 256 ; i++)

   codes[i] = - 1 ;

  for ( int i = 'a' ; i <= 'z' ; i++)

   codes[i] = ( byte ) (i - 'a' );

  for ( int i = 'a' ; i <= 'z' ; i++)

   codes[i] = ( byte ) ( 26 + i - 'a' );

  for ( int i = '0' ; i <= '9' ; i++)

   codes[i] = ( byte ) ( 52 + i - '0' );

  codes[ '+' ] = 62 ;

  codes[ '/' ] = 63 ;

  }

  // /////////////////////////////////////////////////

  // remainder (main method and helper functions) is

  // for testing purposes only, feel free to clip it.

  // /////////////////////////////////////////////////

  public static void main(string[] args) {

  boolean decode = false ;

  if (args.length == 0 ) {

   system.out.println( "usage: java base64 [-d[ecode]] filename" );

   system.exit( 0 );

  }

  for ( int i = 0 ; i < args.length; i++) {

   if ( "-decode" .equalsignorecase(args[i]))

   decode = true ;

   else if ( "-d" .equalsignorecase(args[i]))

   decode = true ;

  }

  string filename = args[args.length - 1 ];

  file file = new file(filename);

  if (!file.exists()) {

   system.out

    .println( "error: file '" + filename + "' doesn't exist!" );

   system.exit( 0 );

  }

  if (decode) {

   char [] encoded = readchars(file);

   byte [] decoded = decode(encoded);

   writebytes(file, decoded);

  } else {

   byte [] decoded = readbytes(file);

   char [] encoded = encode(decoded);

   writechars(file, encoded);

  }

  }

  private static byte [] readbytes(file file) {

  bytearrayoutputstream baos = new bytearrayoutputstream();

  try {

   inputstream fis = new fileinputstream(file);

   inputstream is = new bufferedinputstream(fis);

   int count = 0 ;

   byte [] buf = new byte [ 16384 ];

   while ((count = is.read(buf)) != - 1 ) {

   if (count > 0 )

    baos.write(buf, 0 , count);

   }

   is.close();

  } catch (exception e) {

   e.printstacktrace();

  }

  return baos.tobytearray();

  }

  private static char [] readchars(file file) {

  chararraywriter caw = new chararraywriter();

  try {

   reader fr = new filereader(file);

   reader in = new bufferedreader(fr);

   int count = 0 ;

   char [] buf = new char [ 16384 ];

   while ((count = in.read(buf)) != - 1 ) {

   if (count > 0 )

    caw.write(buf, 0 , count);

   }

   in.close();

  } catch (exception e) {

   e.printstacktrace();

  }

  return caw.tochararray();

  }

  private static void writebytes(file file, byte [] data) {

  try {

   outputstream fos = new fileoutputstream(file);

   outputstream os = new bufferedoutputstream(fos);

   os.write(data);

   os.close();

  } catch (exception e) {

   e.printstacktrace();

  }

  }

  private static void writechars(file file, char [] data) {

  try {

   writer fos = new filewriter(file);

   writer os = new bufferedwriter(fos);

   os.write(data);

   os.close();

  } catch (exception e) {

   e.printstacktrace();

  }

  }

  // /////////////////////////////////////////////////

  // end of test code.

  // /////////////////////////////////////////////////

}

package weaver.general;

import java.io.file;

import java.io.fileinputstream;

import java.util.hashmap;

import java.util.map;

import java.util.properties;

public class basebean {

  private static map<string, properties> propertymap = new hashmap<string, properties>();

  public string getpropvalue(string config_file, string key) {

  if (propertymap.get(config_file) == null ) {

   readpro(config_file);

  }

  properties pro = propertymap.get(config_file);

  return pro.getproperty(key);

  }

  private void readpro(string config_file) {

  properties pro = new properties();

  fileinputstream in;

  try {

   string path = thread.currentthread().getcontextclassloader()

    .getresource( "" ).tostring();

   path = path.substring( 6 , path.indexof( "classes/" ));

   path = path + "prop/" + config_file + ".properties" ;

   path = path.replace( "%20" , " " );

   system.out.println(path);

   file f = new file(path);

   if (!f.exists()) {

   throw new runtimeexception( "要读取的文件不存在" );

   }

   in = new fileinputstream(f);

   pro.load(in);

   in.close();

   propertymap.put(config_file, pro);

  } catch (exception e) {

   e.printstacktrace();

  }

  }

}

package weaver.general;

public class util {

  public static int getintvalue(string value) {

  try {

   return integer.parseint(value);

  } catch (numberformatexception e) {

   e.printstacktrace();

   return 0 ;

  }

  }

}

package com.weaver.formmodel.integration.ocr;

import java.util.hashmap;

import java.util.map;

import net.sf.json.jsonobject;

import org.apache.commons.httpclient.httpstatus;

import org.apache.http.httpentity;

import org.apache.http.httpresponse;

import org.apache.http.statusline;

import org.apache.http.client.httpclient;

import org.apache.http.client.methods.httppost;

import org.apache.http.entity.stringentity;

import org.apache.http.impl.client.defaulthttpclient;

import org.apache.http.params.coreconnectionpnames;

import org.apache.http.util.entityutils;

import weaver.general.basebean;

import weaver.general.util;

public class ocrclient{

  private static string config_file = "ocr_tencent" ;

  private static string host;

  private static int appid;

  private static string secretid;

  private static string secretkey;

  private static string targeturl;

  private static string encoding = "utf-8" ;

  static {

  basebean bb = new basebean();

  host = bb.getpropvalue(config_file, "host" );

  appid = util.getintvalue(bb.getpropvalue(config_file, "appid" ));

  secretid = bb.getpropvalue(config_file, "secretid" );

  secretkey = bb.getpropvalue(config_file, "secretkey" );

  targeturl = bb.getpropvalue(config_file, "targeturl" );

  }

  /**

  * 识别图片

  * @param imageurl

  * @param paramsmap 参数map

  * @return

  * @throws exception

  */

  public static map<string, object> recognizeimage(map<string,object> paramsmap) throws exception{

  httpclient httpclient = new defaulthttpclient();

  httppost httppost = new httppost(targeturl); // 创建httppost 

  httppost.setheader( "host" , host);

  //设置签名

     httppost.setheader( "authorization" , signutil.appsign(appid, secretid, secretkey, "" , 2592000 )); //设置请求头, 签名

     //设置参数

  jsonobject requestparam = new jsonobject();

  requestparam.put( "appid" , string.valueof(appid));

  for (string key :paramsmap.keyset()){ //循环加入请求参数

   requestparam.put(key, paramsmap.get(key));

  }

  //请求报文

     stringentity entity = new stringentity(requestparam.tostring(), encoding);

     entity.setcontentencoding(encoding);

     entity.setcontenttype( "application/json" ); //发送json数据需要设置contenttype

     httppost.setentity(entity);

     httppost.getparams().setparameter(coreconnectionpnames.connection_timeout, 120000 );

     httppost.getparams().setparameter(coreconnectionpnames.so_timeout, 120000 );

     int state = 0 ;

     string result = "" ;

     httpresponse response = null ;

     try {

      response = httpclient.execute(httppost);

       statusline status = response.getstatusline();

       state = status.getstatuscode();

       if (state == httpstatus.sc_ok) {

        httpentity responseentity = response.getentity();

        result = entityutils.tostring(responseentity);

       } else {

   //new basebean().writelog("读取ocr驾驶证或者行驶证接口失败，状态码:"+state);

   }

     } finally {

      httpclient.getconnectionmanager().shutdown();

     }

     map<string, object> resultmap = new hashmap<string, object>();

     resultmap.put( "state" , state);

     resultmap.put( "result" , result);

     return resultmap;

  }

  //测试

  public static void main(string[] args) {

  string imgurl = "https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1532414063478&di=f8709d73023a1a4ef9fe58f23ec95a8e&imgtype=jpg&src=http%3a%2f%2fimg3.imgtn.bdimg.com%2fit%2fu%3d2587099383%2c4041264664%26fm%3d214%26gp%3d0.jpg" ;

  try {

   //车牌号识别参数设置

   map<string, object> requestparam = new hashmap<string, object>();

   requestparam.put( "url" , imgurl);

   map<string,object> res =recognizeimage(requestparam);

   //解析车牌号返回值

   jsonobject resultjson = jsonobject.fromobject(res.get( "result" ));

   system.out.println(resultjson.tostring());

  } catch (exception e) {

   e.printstacktrace();

  }

  }

}