O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Converter a resposta em maiúsculas com uma frase de destaque Java

Você está lendo a documentação do Apigee Edge.
Acesse a documentação da Apigee X. info

Se você estiver testando a chamada de Java pela primeira vez, recomendamos começar com Como criar uma chamada de Java callout.

Este exemplo de livro de receitas demonstra como criar uma política JavaCallout simples que executa um código Java personalizado no contexto de um fluxo de proxy.

O que o exemplo de código faz?

O proxy de API neste exemplo chama um serviço de destino que retorna uma resposta JSON simples. A política de chamada Java é colocada no fluxo de resposta de destino. O código Java converte os cabeçalhos e o conteúdo da resposta em letras maiúsculas. É um exemplo simples, mas ilustra como fazer com que o código Java personalizado funcione no contexto de um proxy de API no Edge.

Testar o exemplo

Fazer o download do projeto

Para simplificar, faça o download deste projeto do repositório api-platform-samples da Apigee no GitHub.

Faça o download ou clone api-platform-samples no seu sistema.
Em um terminal ou editor de código de sua escolha, acesse o api-platform-samples/doc-samples/java-cookbook projeto.

Compilar o código com o Maven

O projeto é configurado para que você possa compilar com o Maven. Se você quiser usar javac, incluiremos um exemplo seguindo o exemplo do Maven.

Verifique se você tem o Maven instalado:
```
mvn -version
```
Execute o script a java-cookbook/buildsetup.sh. Esse script instala as dependências JAR necessárias no seu repositório Maven local.
cd para o diretório java-cookbool/callout.
Execute o Maven:
```
mvn clean package
```
Observação: e aparecer um erro do Maven, verifique se você está no java-cookbook/callout diretório.
Se você quiser, verifique se o arquivo JAR edge-custom-policy-java-cookbook.jar foi copiado para java-cookbook/apiproxy/resources/java. Este é o local necessário para os arquivos JAR que você quer implantar com um proxy.

Compilar com javac

Se você quiser usar javac para compilar o código, faça algo semelhante ao seguinte (do diretório java-cookbook). Os arquivos JAR necessários são fornecidos a você no diretório java-cookbook/lib.

cd para api-platform-samples/doc-samples/java-cookbook.
Verifique se você tem javac no seu caminho.
```
javac -version
```

Execute o seguinte comando javac:

javac -d . -classpath ./lib/expressions-1.0.0.jar:./lib/message-flow-1.0.0.jar:. callout/src/main/java/ResponseUppercase.java

Copie o arquivo JAR para o diretório apiproxy/resources/java. Esse é o local necessário para os arquivos JAR que você quer implantar com um proxy.
```
cp com/apigeesample/ResponseUppercase.class apiproxy/resources/java
```

Implantar e chamar o proxy

Um script de implantação é fornecido no diretório ./java-cookbook. Mas, antes de executá-lo , é necessário fazer uma configuração rápida.

cd para api-platform-samples/doc-samples/java-cookbook
Se ainda não tiver feito isso, abra o arquivo ../../setup/setenv.sh e edite o conforme indicado com as informações da sua conta da Apigee: nome de usuário (o endereço de e-mail associado à sua conta), nome da organização e o domínio usado para fazer chamadas de gerenciamento de API. Por exemplo, para a nuvem do Edge, o domínio é https://api.enterprise.apigee.com. No entanto, seu domínio poderá ser diferente se você estiver usando o Edge Private Cloud.
Salve o arquivo setenv.sh.
Execute o script de implantação:
```
./deploy.sh
```
Se a implantação for bem-sucedida, execute o script de invocação:
```
./invoke.sh
```
O script de invocação chama um comando cURL que se parece com este:
```
curl  http://$org-$env.$api_domain/java-cookbook/json
```

A resposta é algo parecido com isto:

< HTTP/1.1 200 OK
< Date: Tue, 09 May 2017 20:31:08 GMT
< Content-Type: APPLICATION/JSON; CHARSET=UTF-8
< Content-Length: 68
< Connection: keep-alive
< Access-Control-Allow-Origin: *
< ETag: W/"44-RA5ERT/MMLIK54NVBWBSZG"
< X-Powered-By: APIGEE
< Server: Apigee Router
<
* Curl_http_done: called premature == 0
* Connection #0 to host willwitman-test.apigee.net left intact
{"FIRSTNAME":"JOHN","LASTNAME":"DOE","CITY":"SAN JOSE","STATE":"CA"}

Fluxo de proxy

Esta é uma captura de tela da ferramenta de trace mostrando o fluxo do proxy:

Estrutura do proxy

Esta é a estrutura do proxy. Ela inclui um arquivo JAR no apiproxy/resources/java diretório. O JAR é obrigatório. Ele é fornecido para o exemplo, mas, se você estiver fazendo um trabalho personalizado, será necessário criar e copiar para esse local. Para orientações sobre como compilar e implantar uma chamada de Java, consulte Como criar uma chamada de Java callout.

java-cookbook

    apiproxy
        java-cookbook.xml
    policies
        responseUppercase.xml
    proxies
        default.xml
    resources
        java
            ResponseUppercase.jar
    targets
        default.xml

Sobre o código Java

A política de chamada Java executa o código Java a seguir, que converte cabeçalhos de resposta e o corpo da resposta em letras maiúsculas. Observação: o programa usa pacotes específicos da Apigee. Esses pacotes fornecem objetos e métodos que podem ser usados para interagir diretamente com o fluxo de proxy. Existem métodos que permitem receber e definir variáveis de fluxo, cabeçalhos, conteúdo de mensagens e muito mais.

package com.apigeesample;

import com.apigee.flow.execution.ExecutionContext;
import com.apigee.flow.execution.ExecutionResult;
import com.apigee.flow.execution.spi.Execution;
import com.apigee.flow.message.MessageContext;

import java.util.Set; 

public class ResponseUppercase implements Execution{
    public ExecutionResult execute(MessageContext messageContext, ExecutionContext executionContext) {
        try {
            Set headers = messageContext.getMessage().getHeaderNames();
            for (String header : headers) {
                String h = messageContext.getMessage().getHeader(header).toUpperCase();
                messageContext.getMessage().setHeader(header, h);
            }
            String content = messageContext.getMessage().getContent();
            messageContext.getMessage().setContent(content.toUpperCase());
            return ExecutionResult.SUCCESS;
        } catch (Exception e) {
                return ExecutionResult.ABORT;
        }
    }
}

Examinar o proxy de amostra

Deixamos para você abrir o proxy e examinar os arquivos. Esta é a política de chamada Java. Observe como ela referencia a classe que a chamada executa e o arquivo JAR. Todas as políticas de chamada Java seguem esse padrão. Consulte também Política de chamada Java.

<JavaCallout name="responseUppercase">         
    <ClassName>com.apigeesample.ResponseUppercase</ClassName>         
    <ResourceURL>java://ResponseUppercase.jar</ResourceURL> 
</JavaCallout>