java如何调用接口(java调用接口的方法)

  • 时间:
  • 4590人关注

这是一篇关于java相关的编程问答内容,被555位程序员关注,内容涉及到java、调用接口、java接口、java调用接口的方法等,由吕弘深 编辑补充,一起来看下大家的回答。

其实对于java调用接口进行获取对方服务器的数据在开发中特别常见,然而一些常用的基础的知识总是掌握不牢,让人容易忘记,写下来闲的时候看看,比回想总会好一些。

总体而言,一些东西知识点一直复制粘贴容易依赖,重要的是会忘记为什么这么写,只有理解到位,或者八九不离十才可以对于随时变化的情况进行分析,如果到家,还可以对别人或自己的进行优化。

如果你在这篇没有找到你想要的,请点击:java如何调用接口方式二

而对于一些知识点呢,对其进行整理和归纳,这样容易进行对比加深记忆,对下面代码和总结进行对比着看。

首先URL restURL = new URL(url);这其中的url就是需要调的目标接口地址,URL类是java.net.*下的类,这个不陌生。

setRequestMethod("POST");请求方式是有两个值进行选择,一个是GET,一个是POST,选择对应的请求方式

setDoOutput(true);setDoInput(true);

setDoInput()  :  // 设置是否向httpUrlConnection输出,因为这个是post请求,参数要放在http正文内,因此需要设为true, 默认是false;  

setDoOutput():   // 设置是否从httpUrlConnection读入,默认情况下是true;

setAllowUserInteraction();allowUserInteraction 如果为 true,则在允许用户交互(例如弹出一个验证对话框)的上下文中对此 URL 进行检查。

下面代码的query是以  属性=值  传输的,若是多个则是 属性=值&属性=值 这种形式传递的,传递给服务器,让服务器自己去处理。

如何去生成这种形式的呢?最简单最快的方式在这里 Java将Map拼接成“参数=值&参数=值”

close();创建流进行写入或读取返回值,创建用完后记得关闭流。

码农之家
精选回答2:Java标识接口的使用方法

8小时19分钟前回答

标识接口是没有任何方法和属性的接口。标识接口不对实现它的类有任何语义上的要求,它仅仅表明实现它的类属于一个特定的类型。

标接口在Java语言中有一些很著名的应用,比如java.io.Serializable和java.rmi.Remote等接口便是标识接口。标识接口,当一个类实现了一个标识接口之后就像是给自己打了个标签。

为此,我们通过一个通俗而有趣的示例!这个示例是设计一个猎人,其持有一把智能猎枪,这就是说这把猎枪会自动识别人类,若发现瞄准的目标是人类,就不会开火,而其它的任何事物都通杀。

为此,我们使用了下面三个接口:

一个用来表示万事万物的SomeThing

public interface SomeThing {}

人类的接口:

public interface Humans extends SomeThing{}

动物的接口:

public interface Animals extends SomeThing{}

然后是一系列的实现:

中国人:

public class Chinese implements Humans {}

日本人:

public class Japanese {}

狗:

public class Dog implements Animals {}

妖怪(他很聪明,给自己帖上了人的标签):

 public class Monster implements Humans {}

下面这个程序的核心部分,猎人类及客户端程序:

public class Hunter{
 
public void fire(Object target)
{
   if(target instanceof Humans){
    System.out.println("这下完了,打中了一个人,该去坐牢了!");
   }else{
     System.out.println("恭喜你,打中了一只动物!");
   }
}
//智能的枪
public void intelligentFire(Object target)
{
   if(target instanceof Humans){
    return;
   }
   System.out.println("开了一枪!"+target.getClass());
   //下面进行秒杀等相关处理
   //销毁他
   target=null;
}
 
public static void main(String[] args) {
  Hunter hunter=new Hunter();
  Object[]
  objects =new Object[]{new Dog(),new Japanese(),new Japanese(),new Chinese(),new Monster(),new SomeThing(){}};
    for(int i=0; i<objects.length; i++){
       hunter.intelligentFire(objects[i]);
    }
}

运行程序,你会发现输出类似下面结果:

开了一枪!class springroad.demo.taginterface.Dog
开了一枪!class springroad.demo.taginterface.Japanese
开了一枪!class springroad.demo.taginterface.Japanese
开了一枪!class springroad.demo.taginterface.Hunter$1

由此可见,智能猎枪瞄准6个目标,开了4枪。只对Chinese、及Monster的实例没有开枪。因为这里讨论的是标签接口,虽然Humans没有任何方法,但从智能猎枪的角度来看,他就是通过这个标签来判断是否可以开火的。他不用管也管不了目标的层次等级关系(比如Japanese肯定很非常鲜明等级结构),即继承关系。他也管不了目标的来自于哪儿。比如,是用new操作符创建,还是从容器中取,或者是从网络某个地方加载一个。

Hunter只是制订了一个简单的规则,你要想不让我的枪对你开火,你就必须在自己身上帖上一个Humans的标签。也就是说你必须遵守这个规则。

现在回过头来看,因为妖怪Monster真身应该是一条蛇或其它什么动物,但是他懂得Hunter制订的规则,于在巧妙的给自己帖上了一个Humans的标签,以致于欺骗了我们的智能猎枪。

而Japanese则自认为自己了不起,不按规则办事,我就不理你Hunter制订的规则,什么Humans标签,我就是不用。于是放到我们的程序中当然就只有挨杀的份了。

由此可见,空接口(标签接口)的重要性,在像本例中,给不给自己帖上标签,这是一个性命莜关的问题。其实在OO的世界中,空接口可以算是最高的层像。

展开问题
码农之家
精选回答3:JAVA发送http get/post请求,调用http接口、方法详解

17小时20分钟前回答

三个例子 —JAVA发送http get/post请求,调用http接口、方法

例1:使用 HttpClient (commons-httpclient-3.0.jar
jar下载地址:http://xiazai.jb51.net/201904/yuanma/commons-httpclient-3.0.rar

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.methods.InputStreamRequestEntity;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.methods.RequestEntity;

public class HttpTool {

 /**
  * 发送post请求
  * 
  * @author Michael -----CSDN: http://blog.csdn.net/capmiachael
  * @param params
  *   参数
  * @param requestUrl
  *   请求地址
  * @param authorization
  *   授权书
  * @return 返回结果
  * @throws IOException
  */
 public static String sendPost(String params, String requestUrl,
   String authorization) throws IOException {

  byte[] requestBytes = params.getBytes("utf-8"); // 将参数转为二进制流
  HttpClient httpClient = new HttpClient();// 客户端实例化
  PostMethod postMethod = new PostMethod(requestUrl);
  //设置请求头Authorization
  postMethod.setRequestHeader("Authorization", "Basic " + authorization);
  // 设置请求头 Content-Type
  postMethod.setRequestHeader("Content-Type", "application/json");
  InputStream inputStream = new ByteArrayInputStream(requestBytes, 0,
    requestBytes.length);
  RequestEntity requestEntity = new InputStreamRequestEntity(inputStream,
    requestBytes.length, "application/json; charset=utf-8"); // 请求体
  postMethod.setRequestEntity(requestEntity);
  httpClient.executeMethod(postMethod);// 执行请求
  InputStream soapResponseStream = postMethod.getResponseBodyAsStream();// 获取返回的流
  byte[] datas = null;
  try {
   datas = readInputStream(soapResponseStream);// 从输入流中读取数据
  } catch (Exception e) {
   e.printStackTrace();
  }
  String result = new String(datas, "UTF-8");// 将二进制流转为String
  // 打印返回结果
  // System.out.println(result);

  return result;

 }

 /**
  * 从输入流中读取数据
  * 
  * @param inStream
  * @return
  * @throws Exception
  */
 public static byte[] readInputStream(InputStream inStream) throws Exception {
  ByteArrayOutputStream outStream = new ByteArrayOutputStream();
  byte[] buffer = new byte[1024];
  int len = 0;
  while ((len = inStream.read(buffer)) != -1) {
   outStream.write(buffer, 0, len);
  }
  byte[] data = outStream.toByteArray();
  outStream.close();
  inStream.close();
  return data;
 }
}

例2:

import java.io.BufferedReader; 
import java.io.IOException;
import java.io.InputStream; 
import java.io.InputStreamReader; 
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException; 
import java.net.HttpURLConnection; 
import java.net.InetSocketAddress;
import java.net.Proxy;
import java.net.URL; 
import java.net.URLConnection;
import java.util.List;
import java.util.Map;

/** 
 * Http请求工具类 
 * @author snowfigure 
 * @since 2014-8-24 13:30:56 
 * @version v1.0.1 
 */
public class HttpRequestUtil {
 static boolean proxySet = false;
 static String proxyHost = "127.0.0.1";
 static int proxyPort = 8087;
 /** 
  * 编码 
  * @param source 
  * @return 
  */ 
 public static String urlEncode(String source,String encode) { 
  String result = source; 
  try { 
   result = java.net.URLEncoder.encode(source,encode); 
  } catch (UnsupportedEncodingException e) { 
   e.printStackTrace(); 
   return "0"; 
  } 
  return result; 
 }
 public static String urlEncodeGBK(String source) { 
  String result = source; 
  try { 
   result = java.net.URLEncoder.encode(source,"GBK"); 
  } catch (UnsupportedEncodingException e) { 
   e.printStackTrace(); 
   return "0"; 
  } 
  return result; 
 }
 /** 
  * 发起http请求获取返回结果 
  * @param req_url 请求地址 
  * @return 
  */ 
 public static String httpRequest(String req_url) {
  StringBuffer buffer = new StringBuffer(); 
  try { 
   URL url = new URL(req_url); 
   HttpURLConnection httpUrlConn = (HttpURLConnection) url.openConnection(); 

   httpUrlConn.setDoOutput(false); 
   httpUrlConn.setDoInput(true); 
   httpUrlConn.setUseCaches(false); 

   httpUrlConn.setRequestMethod("GET"); 
   httpUrlConn.connect(); 

   // 将返回的输入流转换成字符串 
   InputStream inputStream = httpUrlConn.getInputStream(); 
   InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8"); 
   BufferedReader bufferedReader = new BufferedReader(inputStreamReader); 

   String str = null; 
   while ((str = bufferedReader.readLine()) != null) { 
    buffer.append(str); 
   } 
   bufferedReader.close(); 
   inputStreamReader.close(); 
   // 释放资源 
   inputStream.close(); 
   inputStream = null; 
   httpUrlConn.disconnect(); 

  } catch (Exception e) { 
   System.out.println(e.getStackTrace()); 
  } 
  return buffer.toString(); 
 } 

 /** 
  * 发送http请求取得返回的输入流 
  * @param requestUrl 请求地址 
  * @return InputStream 
  */ 
 public static InputStream httpRequestIO(String requestUrl) { 
  InputStream inputStream = null; 
  try { 
   URL url = new URL(requestUrl); 
   HttpURLConnection httpUrlConn = (HttpURLConnection) url.openConnection(); 
   httpUrlConn.setDoInput(true); 
   httpUrlConn.setRequestMethod("GET"); 
   httpUrlConn.connect(); 
   // 获得返回的输入流 
   inputStream = httpUrlConn.getInputStream(); 
  } catch (Exception e) { 
   e.printStackTrace(); 
  } 
  return inputStream; 
 }


 /**
  * 向指定URL发送GET方法的请求
  * 
  * @param url
  *   发送请求的URL
  * @param param
  *   请求参数,请求参数应该是 name1=value1&name2=value2 的形式。
  * @return URL 所代表远程资源的响应结果
  */
 public static String sendGet(String url, String param) {
  String result = "";
  BufferedReader in = null;
  try {
   String urlNameString = url + "?" + param;
   URL realUrl = new URL(urlNameString);
   // 打开和URL之间的连接
   URLConnection connection = realUrl.openConnection();
   // 设置通用的请求属性
   connection.setRequestProperty("accept", "*/*");
   connection.setRequestProperty("connection", "Keep-Alive");
   connection.setRequestProperty("user-agent",
     "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
   // 建立实际的连接
   connection.connect();
   // 获取所有响应头字段
   Map<String, List<String>> map = connection.getHeaderFields();
   // 遍历所有的响应头字段
   for (String key : map.keySet()) {
    System.out.println(key + "--->" + map.get(key));
   }
   // 定义 BufferedReader输入流来读取URL的响应
   in = new BufferedReader(new InputStreamReader(
     connection.getInputStream()));
   String line;
   while ((line = in.readLine()) != null) {
    result += line;
   }
  } catch (Exception e) {
   System.out.println("发送GET请求出现异常!" + e);
   e.printStackTrace();
  }
  // 使用finally块来关闭输入流
  finally {
   try {
    if (in != null) {
     in.close();
    }
   } catch (Exception e2) {
    e2.printStackTrace();
   }
  }
  return result;
 }

 /**
  * 向指定 URL 发送POST方法的请求
  * 
  * @param url
  *   发送请求的 URL
  * @param param
  *   请求参数,请求参数应该是 name1=value1&name2=value2 的形式。
  * @param isproxy
  *    是否使用代理模式
  * @return 所代表远程资源的响应结果
  */
 public static String sendPost(String url, String param,boolean isproxy) {
  OutputStreamWriter out = null;
  BufferedReader in = null;
  String result = "";
  try {
   URL realUrl = new URL(url);
   HttpURLConnection conn = null;
   if(isproxy){//使用代理模式
    @SuppressWarnings("static-access")
    Proxy proxy = new Proxy(Proxy.Type.DIRECT.HTTP, new InetSocketAddress(proxyHost, proxyPort));
    conn = (HttpURLConnection) realUrl.openConnection(proxy);
   }else{
    conn = (HttpURLConnection) realUrl.openConnection();
   }
   // 打开和URL之间的连接

   // 发送POST请求必须设置如下两行
   conn.setDoOutput(true);
   conn.setDoInput(true);
   conn.setRequestMethod("POST"); // POST方法


   // 设置通用的请求属性

   conn.setRequestProperty("accept", "*/*");
   conn.setRequestProperty("connection", "Keep-Alive");
   conn.setRequestProperty("user-agent",
     "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
   conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");

   conn.connect();

   // 获取URLConnection对象对应的输出流
   out = new OutputStreamWriter(conn.getOutputStream(), "UTF-8");
   // 发送请求参数
   out.write(param);
   // flush输出流的缓冲
   out.flush();
   // 定义BufferedReader输入流来读取URL的响应
   in = new BufferedReader(
     new InputStreamReader(conn.getInputStream()));
   String line;
   while ((line = in.readLine()) != null) {
    result += line;
   }
  } catch (Exception e) {
   System.out.println("发送 POST 请求出现异常!"+e);
   e.printStackTrace();
  }
  //使用finally块来关闭输出流、输入流
  finally{
   try{
    if(out!=null){
     out.close();
    }
    if(in!=null){
     in.close();
    }
   }
   catch(IOException ex){
    ex.printStackTrace();
   }
  }
  return result;
 } 

 public static void main(String[] args) {
  //demo:代理访问
  String url = "http://api.adf.ly/api.php";
  String para = "key=youkeyid&youuid=uid&advert_type=int&domain=adf.ly&url=http://somewebsite.com";

  String sr=HttpRequestUtil.sendPost(url,para,true);
  System.out.println(sr);
 }

}

例3

/**
  * 发送Http post请求
  * 
  * @param xmlInfo
  *   json转化成的字符串
  * @param URL
  *   请求url
  * @return 返回信息
  */
 public static String doHttpPost(String xmlInfo, String URL) {
  System.out.println("发起的数据:" + xmlInfo);
  byte[] xmlData = xmlInfo.getBytes();
  InputStream instr = null;
  java.io.ByteArrayOutputStream out = null;
  try {
   URL url = new URL(URL);
   URLConnection urlCon = url.openConnection();
   urlCon.setDoOutput(true);
   urlCon.setDoInput(true);
   urlCon.setUseCaches(false);
   urlCon.setRequestProperty("content-Type", "application/json");
   urlCon.setRequestProperty("charset", "utf-8");
   urlCon.setRequestProperty("Content-length",
     String.valueOf(xmlData.length));
   System.out.println(String.valueOf(xmlData.length));
   DataOutputStream printout = new DataOutputStream(
     urlCon.getOutputStream());
   printout.write(xmlData);
   printout.flush();
   printout.close();
   instr = urlCon.getInputStream();
   byte[] bis = IOUtils.toByteArray(instr);
   String ResponseString = new String(bis, "UTF-8");
   if ((ResponseString == null) || ("".equals(ResponseString.trim()))) {
    System.out.println("返回空");
   }
   System.out.println("返回数据为:" + ResponseString);
   return ResponseString;

  } catch (Exception e) {
   e.printStackTrace();
   return "0";
  } finally {
   try {
    out.close();
    instr.close();

   } catch (Exception ex) {
    return "0";
   }
  }
 }

以上所述是小编给大家介绍的Java发送http get/post请求调用接口/方法详解整合,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对码农之家网站的支持!

展开问题
码农之家
精选回答4:java关于腾讯ocr图片识别接口调用总结

24小时24分钟前回答

最近开发了一个拍车牌识别车牌号的功能,主要调用了腾讯的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;
 }
 
 }
 
}

然后是接口调配置文件:

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

正主来了,调用接口部分:

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();
 }
 }
}

如需调用其他接口,如身份证识别接口、驾驶证识别接口、等,则只需要修改一下配置文件的targeturl,并且调用时传入相应的参数即可。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持码农之家。

展开问题
码农之家
精选回答5:浅析Java8新特性Lambda表达式和函数式接口

19小时32分钟前回答

什么是Lambda表达式,java8为什么使用Lambda表达式?

“Lambda 表达式”(lambda expression)是一个匿名函数,Lambda表达式基于数学中的λ演算得名,直接对应于其中的lambda抽象(lambda abstraction),是一个匿名函数,即没有函数名的函数。我们可以把 Lambda表达式理解为是 一段可以传递的代码。最直观的是使用Lambda表达式之后不用再写大量的匿名内部类,简化代码,提高了代码的可读性。

  // 启动一个线程,不使用Lambda表达式
  new Thread(new Runnable() {
    @Override
    public void run() {
      System.out.println("启动一个线程");
    }
  }).start();
  //使用Lambda表达式,只需要一行代码
  new Thread(() -> System.out.println("启动一个线程")).start();

Lambda表达式的基本语法和格式

基本语法

  • java8中引入了新的操作符”->”,称为箭头操作符或者lambda操作符,箭头操作符将lambda拆分为两部分,左侧:lambda表达式的参数列表,右侧:lambda表达式中的所需要执行的的功能(接口实现的功能代码)。
  • lambda表达式需要“函数式接口”的支持,接口中只有一个抽象方法的接口称为函数式接口,可以使用注解@FunctionalInterface检查接口是否是函数式接口。
  • lambda表达式的参数列表的数据类型可以省略不写,因为jvm编辑器可以通过上下文判断。
  • 基本格式

① 无参数,无返回值。( ) -> System.out.println(“hello”)

  // 实现Runnable接口(无参,无返回)
  Runnable r = () -> System.out.println("hello lambda");

② 一个参数(小括号可以省略不写,习惯上加上小括号),无返回值。(x) -> System.out.println(x)

  //Consumer接口(一个参数,无返回值),之后会提到
  //第一种,小括号不省略
  Consumer<String> c = (x) -> System.out.print(x);
  c.accept("hello");
  //小括号省略
  Consumer<String> c1 = x -> System.out.print(x);
  c1.accept("hello")

③ 有多个参数,并且lambda有多条语句,则lambda语句必须用大括号括起来并有return返回(若有一条语句则可以省略大括号和return),有返回值。(x,y) ->{System.out.println(“hello”);return Integer.compare(x, y);};

//Comparator接口
  //多条语句
  Comparator<Integer> comparator = (x,y) ->{
    System.out.println("hello");
    return Integer.compare(x, y);
  };
  //一条语句
  Comparator<Integer> comparator2 = (x,y) -> Integer.compare(x, y);
  System.out.println(comparator2.compare(23, 22));

还有其他的一些格式都是大同小异,这里就不再了解。

函数式接口是什么?

在前面也提到了函数接口,那么函数接口到底是什么呢?是个接口,只包含一个抽象方法,那么它就是函数式接口,我们可以在任意函数式接口上使用 @FunctionalInterface 检查它是否是一个函数式接口。
函数式接口里是可以包含默认方法、静态方法,他们不是抽象方法;也可以包含Java.lang.Object里的public方法,因为任何一个类都继承Object类,包含了来自java.lang.Object里对这些抽象方法的实现,也不属于抽象方法;函数式接口里允许子接口继承多个父接口,但每个父接口中都只能存在一个抽象方法,且必须的相同的抽象方法。

Java8内置函数式接口

四大核心函数式接口

函数式接口 方法 参数类型 返回类型 作用
Consumer<T> 消费型接口 void accept(T t) T void 对T类型的参数进行操作
Supplier<T> 供给型接口 T get() T 操作数据,返回T类型的结果
Function<T, R> 函数型接口 R apply(T t) T R 对T类型参数进行操作,并返回R类型的结果
Predicate<T> 断定型接口 boolean test(T t) T boolean 确定T类型参数是否满足某约束,并返回boolean值

//Consumer<T> 消费型接口
  @Test
  public void test1(){
    Consumer<String> c = (x) -> System.out.println("hello:"+x+"!");
    c.accept("Java");
  }
  // Supplier<T> 供给型接口
  @Test
  public void test2(){
    Supplier<String> s = () -> "hello,beautiful girl";
    String str = s.get();
    System.out.println(str);
  }
  //Function<T,R> 函数性接口
  @Test
  public void test3(){
    Function<String, Integer> f= (x) -> x.length();
    Integer len = f.apply("hello");
    System.out.println(len);
  }
  //Predicate<T> 断言型接口
  @Test
  public void test4(){
    Predicate<String> p = (x) -> x.length()>5;
    boolean b = p.test("hello Java");
    System.out.println(b);
  }

其它函数式接口

函数式接口 方法 参数类型 返回类型 作用
BiFunction<T , U, R > R apply(T t, U u) T, U R 对 T, U 类型的参数进行操作,并返回R类型的结果
UnaryOperator<T> (Function 子接口) T apply(T t) T T 对 T类型的参数进行一元运算,并返回R对象的结果
BinaryOperato<T,R> (BiFunction 子接口) ) T apply(T t1, T t2 T, T T 对T类型的参数进行二元运算,并返回T类型的结果
BiConsumer<T, U> void accept(T t, U u) T, U void 对T,作
ToIntToIntFunction<T> ToLongFunction<T> ToDoubleFunction<T> int(long,double) applyAsInt(T value) T int, long, double 计 算 int 、 long 、double值的函数
IntFunction<R> LongFunction<R> DoubleFunction<R> R apply(int(long,double) value) int, long, double R 参数分别为int、long、double 类型的函数

总结

以上所述是小编给大家介绍的Java8新特性Lambda表达式和函数式接口,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对码农之家网站的支持!

展开问题

参考资料

更多回答

17小时26分钟前回答

详解Java 本地接口 JNI 使用方法

详解Java 本地接口 JNI 使用方法 对于Java程序员来说,Java语言的好处和优点,我想不用我说了,大家自然会说出很多一套套的。但虽然我们作为java程序员,但我们不得不承认java语言也有一些它本身的缺点。比如在性能、和底层打交道方面都有它的缺点。所以java就提供了一些本地接口,他主要的作用就是提供一个标准的方式让java程序通过虚拟机与原生代码进行交互,这也就是我们平常常说的java本地接口(JNI——java native Interface)。它使得在 Java 虚拟机 (VM) 内部运行的 Java 代码能够与用其它编程语言(如 C、C++ 和汇编语言)编写的应用程序和库进行互操作。JNI 最重要的好处是它没有对底层 Java 虚拟机的……

46小时18分钟前回答

浅谈Java抽象类和接口的个人理解

今天来说一波自己对Java中抽象类和接口的理解,含参考内容: 一、抽象类 1、定义: public abstract class 类名{} Java语言中所有的对象都是用类来进行描述,但是并不是所有的类都是用来描述对象的。我所理解的抽象类其实就是对同一类事物公共部分的高度提取,这个公共部分包括属性和行为。比如牛、羊、猪它们的公共属性是都有毛,公共行为是都哺乳,所以我们可以把公共部分抽象成一个哺乳类,含有属性毛和行为哺乳,当牛、羊、猪继承了哺乳类后也就有了哺乳的功能,至于怎么完成这个功能就需要自己去实现了。 2、特点 (1)被Abstract关键字修饰的类是抽象类; (2)含有抽象方法的类一定是抽象……