Comment utiliser l'API Google Translate dans mon application Java?

Utiliser java-google-translate-text-to-speech au lieu de Google Translate API v2 Java.

À propos de java-google-translate-text-to-speech

Api non officielle avec les principales fonctionnalités de Google Translate en Java.

Facile à utiliser!

Il fournit également une api de synthèse vocale. Si vous voulez traduire le texte "Bonjour!"en roumain, il suffit d'écrire:

Translator translate = Translator.getInstance();
String text = translate.translate("Hello!", Language.ENGLISH, Language.ROMANIAN);
System.out.println(text); // "Bună ziua!" 

C'est gratuit!

Comme @r0ast3d l'a dit correctement:

Important: Google Translate API v2 est maintenant disponible en tant que service payant. La limite de courtoisie pour les projets Translate API v2 existants créés avant le 24 août 2011 sera réduite à zéro le 1er décembre 2011. De plus, le nombre de demandes que votre demande peut faire par jour sera limité.

Ceci est correct: il suffit de voir la page officielle :

Google Translate API est disponible en tant que service payant. Consultez les pages Tarifs et FAQ pour plus de détails.

MAIS, java-google-translate-text-to-speech est GRATUIT!

Exemple!

J'ai créé un exemple d'application qui démontre que cela fonctionne. Essayez-le ici: https://github.com/IonicaBizau/text-to-speech

Vous pouvez utiliser script google qui a GRATUITE l'API de traduire. Tout ce dont vous avez besoin est un compte Google commun et faites ces TROIS ÉTAPES FACILES.
1) Créer un nouveau script avec un tel code script google:

var mock = {
  parameter:{
    q:'hello',
    source:'en',
    target:'fr'
  }
};


function doGet(e) {
  e = e || mock;

  var sourceText = ''
  if (e.parameter.q){
    sourceText = e.parameter.q;
  }

  var sourceLang = '';
  if (e.parameter.source){
    sourceLang = e.parameter.source;
  }

  var targetLang = 'en';
  if (e.parameter.target){
    targetLang = e.parameter.target;
  }

  var translatedText = LanguageApp.translate(sourceText, sourceLang, targetLang, {contentType: 'html'});

  return ContentService.createTextOutput(translatedText).setMimeType(ContentService.MimeType.JSON);
}

2) Cliquez sur Publier -> Déployer sous la forme d'une webapp -> Qui a accès à l'application: tous, même anonyme -> Déployer. Et puis copiez l'URL de votre application Web, vous en aurez besoin pour appeler l'API translate.

3) Utilisez ce code java pour tester votre API:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;

public class Translator {

    public static void main(String[] args) throws IOException {
        String text = "Hello world!";
        //Translated text: Hallo Welt!
        System.out.println("Translated text: " + translate("en", "de", text));
    }

    private static String translate(String langFrom, String langTo, String text) throws IOException {
        // INSERT YOU URL HERE
        String urlStr = "https://your.google.script.url" +
                "?q=" + URLEncoder.encode(text, "UTF-8") +
                "&target=" + langTo +
                "&source=" + langFrom;
        URL url = new URL(urlStr);
        StringBuilder response = new StringBuilder();
        HttpURLConnection con = (HttpURLConnection) url.openConnection();
        con.setRequestProperty("User-Agent", "Mozilla/5.0");
        BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
        String inputLine;
        while ((inputLine = in.readLine()) != null) {
            response.append(inputLine);
        }
        in.close();
        return response.toString();
    }

}

Comme il est libre, il y a DES LIMITES DE QUATA: https://docs.google.com/macros/dashboard

Générer votre propre clé API ici. Consultez la documentationici .

Vous devrez peut-être configurer un compte de facturation lorsque vous essayez d'activer la Google Cloud Translation API dans votre compte.

Voici un exemple de démarrage rapide qui traduit deux chaînes English en Spanish:

import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.Arrays;

import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.translate.Translate;
import com.google.api.services.translate.model.TranslationsListResponse;
import com.google.api.services.translate.model.TranslationsResource;

public class QuickstartSample
{
    public static void main(String[] arguments) throws IOException, GeneralSecurityException
    {
        Translate t = new Translate.Builder(
                GoogleNetHttpTransport.newTrustedTransport()
                , GsonFactory.getDefaultInstance(), null)
                // Set your application name
                .setApplicationName("Stackoverflow-Example")
                .build();
        Translate.Translations.List list = t.new Translations().list(
                Arrays.asList(
                        // Pass in list of strings to be translated
                        "Hello World",
                        "How to use Google Translate from Java"),
                // Target language
                "ES");

        // TODO: Set your API-Key from https://console.developers.google.com/
        list.setKey("your-api-key");
        TranslationsListResponse response = list.execute();
        for (TranslationsResource translationsResource : response.getTranslations())
        {
            System.out.println(translationsResource.getTranslatedText());
        }
    }
}

Dépendances maven requises pour l'extrait de code:

<dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>google-cloud-translate</artifactId>
    <version>LATEST</version>
</dependency>

<dependency>
    <groupId>com.google.http-client</groupId>
    <artifactId>google-http-client-gson</artifactId>
    <version>LATEST</version>
</dependency>

Vous pouvez utiliser Google Translate API v2 Java. Il a un module de base que vous pouvez appeler à partir de votre code Java et aussi un module d'interface de ligne de commande.