Java开发使用百度翻译api

1、先注册一个 百度翻译api 帐户，申请官方授权，注册官网如下：

      http://api.fanyi.baidu.com/api/trans/product/index

2、申请成功后下载java版demo，其实就是一个工程文件

3、下载好之后将工程文件导入eclipse，导入成功后，在Main类中将变量 APP_ID ，SECURITY_KEY  设为你申请到的APP ID与密匙，APP ID与密匙在开发者信息里找

4、填入id与密匙就能直接使用了，

   我们要用到的是TransApi 类中的 getTransResult(String A, String B, String C)方法，A是需要翻译的内容，B是翻译源语言，C是译文语言。自动对应的是 "auto"，中文对应"zh",英文对应"en"，译文语言不能设为自动，其他语言简写可以到官网上自行查找。

    函数返回结果是josn字段，结构如下

    {"from":"zh","to":"en","trans_result":[{"src":"\u9ad8\u5ea6600\u7c73","dst":"Height of 600 meters"}]}

5、解析json，方法有很多种，这里用的是googol的gson来解析，使用gson需要下载gson的jar文件，大家可以自行到网上下载，下载后将jar文件导入项目中即可。

下面直接上源码：

package com.wangfei.service;

import com.google.gson.Gson;
import com.wangfei.pojo.TranslateResult;
import com.wangfei.util.MD5;
import com.wangfei.util.MyX509TrustManager;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.security.MessageDigest;

/**
 *百度翻译API工具
 */
public class BaiduTranslateService {

    private static Logger logger = LoggerFactory.getLogger(BaiduTranslateService.class);

    protected static final int SOCKET_TIMEOUT = 10000; // 10S
    /**
     * 发起http请求获取返回结果
     *
     * @param requestUrl 请求地址
     * @return
     */
    public static String httpRequest(String requestUrl) {
        StringBuffer buffer = new StringBuffer();
        try {

            // 设置SSLContext
            SSLContext sslcontext = SSLContext.getInstance("TLS");
            sslcontext.init(null, new TrustManager[] { new MyX509TrustManager() }, null);

            URL url = new URL(requestUrl);
            HttpURLConnection httpUrlConn = (HttpURLConnection) url.openConnection();
            if (httpUrlConn instanceof HttpsURLConnection) {
                ((HttpsURLConnection) httpUrlConn).setSSLSocketFactory(sslcontext.getSocketFactory());
            }
            httpUrlConn.setConnectTimeout(SOCKET_TIMEOUT); // 设置相应超时

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

            int statusCode = httpUrlConn.getResponseCode();

            if (statusCode != HttpURLConnection.HTTP_OK) {
                logger.info("Http错误码：" + statusCode);
            }

            // 将返回的输入流转换成字符串
            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();
            httpUrlConn.disconnect();

        } catch (Exception e) {
            e.printStackTrace();
        }
        return buffer.toString();
    }

    /**
     * utf编码
     *
     * @param source
     * @return
     */
    public static String urlEncodeUTF8(String source) {
        String result = source;
        try {
            result = URLEncoder.encode(source, "utf-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 翻译（中->英 英->中 日->中 ）
     *
     * @param querySource
     * @return
     */
    public static String translate(String querySource, String from, String to) {
        String dst = null;

        // 百度翻译官方api
        String url = "http://api.fanyi.baidu.com/api/trans/vip/translate";
        // 需要改成自己的APP ID
        String APPID = "填写自己的APPID";
        // 需要改成自己的密钥
        String KEY = "填写自己密钥";
        // 随机数，官方提供的是获取时间
        String SALT = Long.toString(System.currentTimeMillis());
        // 对签名做md5加密
        String SIGN = MD5.md5(APPID + querySource + SALT + KEY);

        // 组装查询地址  // 添加参数，并对参数的值进行urlEncode utf-8编码
        StringBuffer requestUrl = new StringBuffer(url);
        requestUrl.append("?");
        requestUrl.append("q");
        requestUrl.append("=");
        requestUrl.append(urlEncodeUTF8(querySource));
        requestUrl.append("&");
        requestUrl.append("from");
        requestUrl.append("=");
        requestUrl.append(urlEncodeUTF8(from));
        requestUrl.append("&");
        requestUrl.append("to");
        requestUrl.append("=");
        requestUrl.append(urlEncodeUTF8(to));
        requestUrl.append("&");
        requestUrl.append("appid");
        requestUrl.append("=");
        requestUrl.append(urlEncodeUTF8(APPID));
        requestUrl.append("&");
        requestUrl.append("salt");
        requestUrl.append("=");
        requestUrl.append(urlEncodeUTF8(SALT));
        requestUrl.append("&");
        requestUrl.append("sign");
        requestUrl.append("=");
        requestUrl.append(urlEncodeUTF8(SIGN));


        // 查询并解析结果
        try {
            // 查询并获取返回结果
            String json = httpRequest(requestUrl.toString());
            logger.info("调用翻译Api的结果" + json);
            // 通过Gson工具将json转换成TranslateResult对象
            TranslateResult translateResult = new Gson().fromJson(json, TranslateResult.class);
            // 取出translateResult中的译文
            dst = translateResult.getTrans_result().get(0).getDst();
        } catch (Exception e) {
            e.printStackTrace();
        }

        if (null == dst) {
            dst = "翻译系统异常，请稍候尝试！";
        }
        return dst;
    }

    public static String getMD5String(String str) {
        try {
            // 生成一个MD5加密计算摘要
            MessageDigest md = MessageDigest.getInstance("MD5");
            // 计算md5函数
            md.update(str.getBytes());
            // digest()最后确定返回md5 hash值，返回值为8位字符串。因为md5 hash值是16位的hex值，实际上就是8位的字符
            // BigInteger函数则将8位的字符串转换成16位hex值，用字符串来表示；得到字符串形式的hash值
            //一个byte是八位二进制，也就是2位十六进制字符（2的8次方等于16的2次方）
            return new BigInteger(1, md.digest()).toString(16);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    public static void main(String[] args) {
        
        // 翻译结果：网络非常强大
        String querySource = "The network really powerful";
        String from = "auto";
        String to = "zh";
        String str = translate(querySource,from,to);
        System.out.println("翻译结果====" + str);

    }
}

java   MD5 加密

package com.wangfei.util;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * MD5编码相关的类
 */
public class MD5 {
    // 首先初始化一个字符数组，用来存放每个16进制字符
    private static final char[] hexDigits = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd',
            'e', 'f' };

    /**
     * 获得一个字符串的MD5值
     *
     * @param input 输入的字符串
     * @return 输入字符串的MD5值
     *
     */
    public static String md5(String input) {
        if (input == null)
            return null;

        try {
            // 拿到一个MD5转换器（如果想要SHA1参数换成”SHA1”）
            MessageDigest messageDigest = MessageDigest.getInstance("MD5");
            // 输入的字符串转换成字节数组
            byte[] inputByteArray = input.getBytes("utf-8");
            // inputByteArray是输入字符串转换得到的字节数组
            messageDigest.update(inputByteArray);
            // 转换并返回结果，也是字节数组，包含16个元素
            byte[] resultByteArray = messageDigest.digest();
            // 字符数组转换成字符串返回
            return byteArrayToHex(resultByteArray);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取文件的MD5值
     *
     * @param file
     * @return
     */
    public static String md5(File file) {
        try {
            if (!file.isFile()) {
                System.err.println("文件" + file.getAbsolutePath() + "不存在或者不是文件");
                return null;
            }

            FileInputStream in = new FileInputStream(file);

            String result = md5(in);

            in.close();

            return result;

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return null;
    }

    public static String md5(InputStream in) {

        try {
            MessageDigest messagedigest = MessageDigest.getInstance("MD5");

            byte[] buffer = new byte[1024];
            int read = 0;
            while ((read = in.read(buffer)) != -1) {
                messagedigest.update(buffer, 0, read);
            }

            in.close();

            String result = byteArrayToHex(messagedigest.digest());

            return result;
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return null;
    }

    private static String byteArrayToHex(byte[] byteArray) {
        // new一个字符数组，这个就是用来组成结果字符串的（解释一下：一个byte是八位二进制，也就是2位十六进制字符（2的8次方等于16的2次方））
        char[] resultCharArray = new char[byteArray.length * 2];
        // 遍历字节数组，通过位运算（位运算效率高），转换成字符放到字符数组中去
        int index = 0;
        for (byte b : byteArray) {
            resultCharArray[index++] = hexDigits[b >>> 4 & 0xf];
            resultCharArray[index++] = hexDigits[b & 0xf];
        }

        // 字符数组组合成字符串返回
        return new String(resultCharArray);

    }

}