调用百度识别（图片识别成文字）

引入依赖

  1.         <dependency>
  2.             <groupId>org.json</groupId>
  3.             <artifactId>json</artifactId>
  4.             <version>20171018</version>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>org.apache.httpcomponents</groupId>
  8.             <artifactId>httpclient</artifactId>
  9.             <version>4.5.12</version>
  10.         </dependency>

创建类：AuthService

  2. import org.json.JSONObject;
  4. import java.io.BufferedReader;
  5. import java.io.InputStreamReader;
  6. import java.net.HttpURLConnection;
  7. import java.net.URL;
  8. import java.util.List;
  9. import java.util.Map;
  11. /**
  12.  * 获取token类
  13.  */
  14. public class AuthService {
  16.     /**
  17.      * 获取权限token
  18.      * @return 返回示例：
  19.      * {
  20.      * "access_token": "24.460da4889caad24cccdb1fea17221975.2592000.1491995545.282335-1234567",
  21.      * "expires_in": 2592000
  22.      * }
  23.      */
  24.     public static String getAuth() {
  25.         // 官网获取的 API Key 更新为你注册的
  26.         String clientId = "wcgOtfNCskCzoLqXR1PARIhP";
  27.         // 官网获取的 Secret Key 更新为你注册的
  28.         String clientSecret = "oxwe4afM0hqGOfnSxp7DCdjvB0yATeVG";
  29.         return getAuth(clientId, clientSecret);
  30.     }
  32.     /**
  33.      * 获取API访问token
  34.      * 该token有一定的有效期，需要自行管理，当失效时需重新获取.
  35.      * @param ak - 百度云官网获取的 API Key
  36.      * @param sk - 百度云官网获取的 Securet Key
  37.      * @return assess_token 示例：
  38.      * "24.460da4889caad24cccdb1fea17221975.2592000.1491995545.282335-1234567"
  39.      */
  40.     public static String getAuth(String ak, String sk) {
  41.         // 获取token地址
  42.         String authHost = "https://aip.baidubce.com/oauth/2.0/token?";
  43.         String getAccessTokenUrl = authHost
  44.                 // 1. grant_type为固定参数
  45.                 + "grant_type=client_credentials"
  46.                 // 2. 官网获取的 API Key
  47.                 + "&client_id=" + ak
  48.                 // 3. 官网获取的 Secret Key
  49.                 + "&client_secret=" + sk;
  50.         try {
  51.             URL realUrl = new URL(getAccessTokenUrl);
  52.             // 打开和URL之间的连接
  53.             HttpURLConnection connection = (HttpURLConnection) realUrl.openConnection();
  54.             connection.setRequestMethod("GET");
  55.             connection.connect();
  56.             // 获取所有响应头字段
  57.             Map<String, List<String>> map = connection.getHeaderFields();
  58.             // 遍历所有的响应头字段
  59.             for (String key : map.keySet()) {
  60.                 System.err.println(key + "--->" + map.get(key));
  61.             }
  62.             // 定义 BufferedReader输入流来读取URL的响应
  63.             BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
  64.             String result = "";
  65.             String line;
  66.             while ((line = in.readLine()) != null) {
  67.                 result += line;
  68.             }
  69.             /**
  70.              * 返回结果示例
  71.              */
  72.             System.err.println("result:" + result);
  73.             JSONObject jsonObject = new JSONObject(result);
  74.             String access_token = jsonObject.getString("access_token");
  75.             return access_token;
  76.         } catch (Exception e) {
  77.             System.err.printf("获取token失败！");
  78.             e.printStackTrace(System.err);
  79.         }
  80.         return null;
  81.     }
  83. }

创建类：BaseImg64

  1. import sun.misc.BASE64Encoder;
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.net.URLEncoder;
  8. /**
  9.  * 图片转化base64后再UrlEncode结果
  10.  */
  12. public class BaseImg64 {
  13.     /**
  14.      * 将一张本地图片转化成Base64字符串
  15.      */
  16.     public static String getImageStrFromPath(String imgPath) {
  17.         InputStream in;
  18.         byte[] data = null;
  19.         // 读取图片字节数组
  20.         try {
  21.             in = new FileInputStream(imgPath);
  22.             data = new byte[in.available()];
  23.             in.read(data);
  24.             in.close();
  25.         } catch (IOException e) {
  26.             e.printStackTrace();
  27.         }
  28.         // 对字节数组Base64编码
  29.         BASE64Encoder encoder = new BASE64Encoder();
  30.         // 返回Base64编码过再URLEncode的字节数组字符串
  31.         return URLEncoder.encode(encoder.encode(data));
  32.     }
  33. }

创建类：Check

  1. import org.apache.http.HttpResponse;
  2. import org.apache.http.client.HttpClient;
  3. import org.apache.http.client.methods.HttpPost;
  4. import org.apache.http.entity.StringEntity;
  5. import org.apache.http.impl.client.DefaultHttpClient;
  6. import org.apache.http.util.EntityUtils;
  8. import java.io.File;
  9. import java.io.IOException;
  10. import java.net.URI;
  11. import java.net.URISyntaxException;
  13. /**
  14.  * 图像文字识别
  15.  */
  17. public class Check {
  18.     private static final String POST_URL = "https://aip.baidubce.com/rest/2.0/ocr/v1/general_basic?access_token=" + AuthService.getAuth();
  20.     /**
  21.      * 识别本地图片的文字
  22.      */
  23.     public static String checkFile(String path) throws URISyntaxException, IOException {
  24.         File file = new File(path);
  25.         if (!file.exists()) {
  26.             throw new NullPointerException("图片不存在");
  27.         }
  28.         String image = BaseImg64.getImageStrFromPath(path);
  29.         String param = "image=" + image;
  30.         return post(param);
  31.     }
  33.     /**
  34.      * 图片url
  35.      * 识别结果，为json格式
  36.      */
  37.     public static String checkUrl(String url) throws IOException, URISyntaxException {
  38.         String param = "url=" + url;
  39.         return post(param);
  40.     }
  42.     /**
  43.      * 通过传递参数：url和image进行文字识别
  44.      */
  45.     private static String post(String param) throws URISyntaxException, IOException {
  46.         //开始搭建post请求
  47.         HttpClient httpClient = new DefaultHttpClient();
  48.         HttpPost post = new HttpPost();
  49.         URI url = new URI(POST_URL);
  50.         post.setURI(url);
  51.         //设置请求头，请求头必须为application/x-www-form-urlencoded，因为是传递一个很长的字符串，不能分段发送
  52.         post.setHeader("Content-Type", "application/x-www-form-urlencoded");
  53.         StringEntity entity = new StringEntity(param);
  54.         post.setEntity(entity);
  55.         HttpResponse response = httpClient.execute(post);
  56. //        System.out.println(response.toString());
  57.         if (response.getStatusLine().getStatusCode() == 200) {
  58.             String str;
  59.             try {
  60.                 //读取服务器返回过来的json字符串数据
  61.                 str = EntityUtils.toString(response.getEntity());
  62.                 System.out.println(str);
  63.                 return str;
  64.             } catch (Exception e) {
  65.                 e.printStackTrace();
  66.                 return null;
  67.             }
  68.         }
  69.         return null;
  70.     }
  72.     public static void main(String[] args) {
  73.         String path = "/Users/keliang/Desktop/data/name.jpeg";
  74.         try {
  75.             long now = System.currentTimeMillis();
  76.             checkFile(path);
  77.             System.out.println("耗时：" + (System.currentTimeMillis() - now) / 1000 + "s");
  78.         } catch (URISyntaxException | IOException e) {
  79.             e.printStackTrace();
  80.         }
  81.     }
  82. }