Étant donné que l'API de traduction de Google doit être facturée, j'ai pensé à un moyen de la voler.
1. Utilisez HttpClient pour envoyer une demande http://translate.google.com
2. Utilisez ensuite Jsoupparse html pour extraire le texte traduit.
Copiez le code comme suit :
/**
* Copyright (c) blackbear, Inc. Tous droits réservés.
*/
paquet org.bb.util.i18n ;
importer java.io.InputStream ;
importer java.net.URLEncoder ;
importer java.text.MessageFormat ;
importer org.apache.commons.io.IOUtils ;
importer org.bb.util.net.http.HttpClientUtil ;
importer org.jsoup.Jsoup ;
importer org.jsoup.nodes.Document ;
importer org.jsoup.nodes.Element ;
/**
* TraduireUtil
*
* <pre>Outil de traduction
*PS : via Google Translate
* </pre>
*
* @auteur catty
* @version 1.0, créée le 2/9/2011
*/
classe publique TranslateUtil {
chaîne finale statique protégée URL_TEMPLATE = "http://translate.google.com/?langpair={0}&text={1}" ;
chaîne finale statique protégée ID_RESULTBOX = "result_box" ;
chaîne finale statique protégée ENCODING = "UTF-8" ;
protected static final String AUTO = "auto" ; // Google détermine automatiquement le système source
protected static final String TAIWAN = "zh-TW" ; // Chinois traditionnel
chaîne finale statique protégée CHINE = "zh-CN" // support
protected static final String ENGLISH = "en" // Anglais;
protected static final String JAPAN = "ja" // jour
/**
* <pre>Google traduit
*PS : laissez à Google le soin de déterminer le système source
* </pre>
*
* Texte @param
* @param target_lang système cible
* @retour
* @throwsException
*/
public static String Translate (texte de la chaîne finale, chaîne finale target_lang) lève une exception {
return traduire (texte, AUTO, target_lang);
}
/**
* <pre>Traduction Google</pre>
*
* Texte @param
* @param src_lang système source
* @param target_lang système cible
* @retour
* @throwsException
*/
traduction de chaîne statique publique (texte de chaîne final, chaîne finale src_lang, chaîne finale target_lang)
lance une exception {
InputStream est = null ;
Document doc = nul ;
Élément élément = nul ;
essayer {
// crée une chaîne d'URL
URL de chaîne = MessageFormat.format(URL_TEMPLATE,
URLEncoder.encode(src_lang + "|" + target_lang, ENCODING),
URLEncoder.encode(texte, ENCODAGE));
// se connecte et télécharge le HTML
est = HttpClientUtil.downloadAsStream(url);
// analyser le HTML par Jsoup
doc = Jsoup.parse(est, ENCODING, "");
ele = doc.getElementById(ID_RESULTBOX);
Résultat de la chaîne = ele.text();
renvoyer le résultat ;
} enfin {
IOUtils.closeQuietly(est);
est = nul ;
doc = nul ;
ele = nul ;
}
}
/**
* <pre>Traduction Google : chinois -> chinois traditionnel</pre>
*
* Texte @param
* @retour
* @throwsException
*/
public static String cn2tw (texte de chaîne final) lève une exception {
return traduire (texte, CHINE, TAIWAN);
}
/**
* <pre>Traduction Google : Chinois traditionnel-->中文</pre>
*
* Texte @param
* @retour
* @throwsException
*/
public static String tw2cn (texte de chaîne final) lève une exception {
return traduire (texte, TAIWAN, CHINE);
}
/**
* <pre>Traduction Google : anglais-->chinois traditionnel</pre>
*
* Texte @param
* @retour
* @throwsException
*/
public static String en2tw (texte de chaîne final) lève une exception {
return traduire (texte, ANGLAIS, TAIWAN);
}
/**
* <pre>Traduction Google : chinois traditionnel-->anglais</pre>
*
* Texte @param
* @retour
* @throwsException
*/
public static String tw2en (texte de chaîne final) lève une exception {
return traduire (texte, TAIWAN, ANGLAIS);
}
/**
* <pre>Traduction Google : japonais-->chinois traditionnel</pre>
*
* Texte @param
* @retour
* @throwsException
*/
public static String jp2tw (texte de chaîne final) lève une exception {
return traduire (texte, JAPON, TAIWAN);
}
/**
* <pre>Traduction Google : chinois traditionnel-->japonais</pre>
*
* Texte @param
* @retour
* @throwsException
*/
public static String tw2jp (texte de chaîne final) lève une exception {
return traduire (texte, TAIWAN, JAPON);
}
}
HttpClientUtil.java
Copiez le code comme suit :
/**
* Copyright (c) Blackbear, Inc. Tous droits réservés.
*/
paquet org.bb.util.net.http ;
importer java.io.BufferedInputStream ;
importer java.io.File ;
importer java.io.FileOutputStream ;
importer java.io.InputStream ;
importer java.util.Map ;
importer org.apache.commons.io.IOUtils ;
importer org.apache.commons.logging.Log ;
importer org.apache.commons.logging.LogFactory ;
importer org.apache.http.HttpEntity ;
importer org.apache.http.HttpResponse ;
importer org.apache.http.client.HttpClient ;
importer org.apache.http.client.methods.HttpGet ;
importer org.apache.http.client.methods.HttpPost ;
importer org.apache.http.client.methods.HttpRequestBase ;
importer org.apache.http.conn.scheme.PlainSocketFactory ;
importer org.apache.http.conn.scheme.Scheme ;
importer org.apache.http.conn.scheme.SchemeRegistry ;
importer org.apache.http.conn.ssl.SSLSocketFactory ;
importer org.apache.http.entity.BufferedHttpEntity ;
importer org.apache.http.impl.client.DefaultHttpClient ;
importer org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager ;
importer org.apache.http.params.BasicHttpParams ;
/**
*PostUtil.java
*
* @auteur catty
* @version 1.0, créée le 20/02/2008
*/
classe publique HttpClientUtil {
Journal de journal statique protégé = LogFactory.getLog (HttpClientUtil.class);
HttpClient statique protégé httpclient = null ;
protégé statique int maxTotal = 200 ;
protégé static int maxPerRoute = 20 ;
protected static String userAgent = "Mozilla/5.0 (Windows NT 6.1 ; WOW64) AppleWebKit/535.7 (KHTML, comme Gecko) Chrome/16.0.912.77 Safari/535.7" ;
statique {
si (httpclient == null) {
// ~~~~~~~~~~~~~~~~~~~~
// crée le client http
// ~~~~~~~~~~~~~~~~~~~~
SchemeRegistry reg = new SchemeRegistry();
reg.register(new Scheme("http", 80, PlainSocketFactory.getSocketFactory()));
reg.register(new Scheme("https", 443, SSLSocketFactory.getSocketFactory()));
ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(reg);
cm.setMaxTotal(maxTotal);
cm.setDefaultMaxPerRoute(maxPerRoute);
httpclient = nouveau DefaultHttpClient(cm);
}
}
/**
* <pre>Revenir à Inputstream la prochaine fois</pre>
*
* URL @param
* @retour
* @throwsException
*/
public static InputStream downloadAsStream (String url) lève une exception {
InputStream est = (InputStream) download(url, null, null, false);
le retour est ;
}
/**
* <pre>Enregistrer dans un fichier après le téléchargement</pre>
*
* URL @param
* @param saveFile
* @throwsException
*/
Le téléchargement public static void (String url, File saveFile) lève une exception {
télécharger (url, saveFile, null, false);
}
/**
* <pre>下</pre>
*
* URL @param
* @param saveFile
* @param paramètres
* @param isPost
* @return Si saveFile==null retourne au flux d'entrée, sinon retourne à saveFile
* @throwsException
*/
téléchargement d'objet statique public (URL finale de la chaîne, fichier final saveFile, paramètres finaux Map<String, String>,
le booléen final isPost) lève une exception {
booléen saveToFile = saveFile != null;
// vérifie que le répertoire existe ??
if (saveToFile && saveFile.getParentFile().exists() == false) {
saveFile.getParentFile().mkdirs();
}
Erreur d'exception = null ;
Requête HttpRequestBase = null ;
Réponse HttpResponse = null ;
Entité HttpEntity = null ;
FileOutputStream fos = null ;
Résultat de l'objet = null ;
essayer {
//créer une demande
si (isPost) {
requête = nouveau HttpPost(url);
} autre {
requête = nouveau HttpGet(url);
}
// ajoute l'en-tête et les paramètres
addHeaderAndParams(requête, paramètres);
// connecter
réponse = httpclient.execute(requête);
entité = réponse.getEntity();
entité = nouveau BufferedHttpEntity(entité);
//obtenir le résultat
if (saveToFile) {// enregistrer sur le disque
fos = nouveau FileOutputStream(saveFile);
IOUtils.copy(entity.getContent(), fos);
résultat = saveFile ;
} else { // se déforme vers inpustream
result = new BufferedInputStream(entity.getContent());
}
} attraper (Exception e) {
erreur = e;
} enfin {
// fermer
IOUtils.closeQuietly(fos);
// clair
demande = nulle ;
réponse = nulle ;
entité = nulle ;
si (erreur != null) {
jeter l'erreur;
}
renvoyer le résultat ;
}
}
protected static void addHeaderAndParams (requête finale HttpRequestBase, paramètres finaux Map<String, String>) {
// ajoute l'en-tête par défaut
request.addHeader("User-Agent", userAgent);
// ajoute des paramètres
si (params != null) {
// carte --> HttpParams
BasicHttpParams myParams = new BasicHttpParams();
pour (clé de chaîne : params.keySet()) {
myParams.setParameter(clé, params.get(clé));
}
request.setParams(myParams);
}
}
public statique HttpClient getHttpclient() {
renvoyer le client http ;
}
public static void setHttpclient (HttpClient httpclient) {
HttpClientUtil.httpclient = httpclient;
}
public statique int getMaxTotal() {
retourner maxTotal ;
}
public static void setMaxTotal(int maxTotal) {
HttpClientUtil.maxTotal = maxTotal ;
}
public statique int getMaxPerRoute() {
retourner maxPerRoute ;
}
public static void setMaxPerRoute (int maxPerRoute) {
HttpClientUtil.maxPerRoute = maxPerRoute ;
}
chaîne statique publique getUserAgent() {
retourner userAgent ;
}
public static void setUserAgent (String userAgent) {
HttpClientUtil.userAgent = userAgent ;
}
}