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.

Como usar propriedades em uma chamada de Java

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

O que é uma chamada de Java?

Se você é iniciante nas chamadas do Java, comece com Como criar uma frase de destaque Java.

Como usar propriedades em uma chamada de Java

As propriedades permitem especificar pares de nome/valor em uma política de chamada de Java que pode ser acessada a partir do seu código Java no ambiente de execução. Você precisa especificar um valor de string literal para cada propriedade. Não é possível referenciar variáveis de fluxo neste elemento.

Veja um exemplo simples de chamada Java que usa propriedades. Neste exemplo, criamos um proxy com uma política de chamada de Java. A política usa o elemento <Properties> para especificar um par de nome/valor. No código Java, recuperamos o valor e o usamos para definir um cabeçalho de resposta.

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 projeto api-platform-samples/doc-samples/java-properties.

Política de chamadas do Java

A política usa o elemento <Properties>. Esse elemento permite especificar pares de nome/valor. No ambiente de execução, seu código Java pode acessar os valores das propriedades especificadas na política, como veremos em breve.

<JavaCallout name="java-callout">         
    <ClassName>com.apigeesample.JavaProperties</ClassName>         
    <ResourceURL>java://edge-custom-policy-java-properties.jar</ResourceURL>         
    <Properties>              
        <Property name="prop">WORLD!</Property>             
    </Properties> 
</JavaCallout>

A amostra de código Java

O código Java dessa amostra mostra como recuperar uma propriedade que foi especificada na política de chamada de Java. No projeto de amostra, você encontra o código-fonte em java-properties/callout/src/main/java/JavaProperties.java. Mostraremos as etapas para compilar e implantar esse código posteriormente neste tópico.

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.Map;

public class JavaProperties implements Execution {

	private Map <String,String> properties; // read-only

	public JavaProperties(Map <String,String> properties) {
	        this.properties = properties;
	}

	public ExecutionResult execute(MessageContext messageContext, ExecutionContext executionContext) {

		try {

		    messageContext.getMessage().setHeader("X-PROPERTY-HELLO", this.properties.get("prop"));

            return ExecutionResult.SUCCESS;

		} catch (Exception e) {
			return ExecutionResult.ABORT;
		}
	}
}

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 também.

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

Compilar com javac (opcional)

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

cd para api-platform-samples/doc-samples/java-properties.
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/JavaProperties.java

Crie um arquivo JAR:

jar -cvf edge-custom-policy-java-properties.jar ./com/apigeesample/JavaProperties.class
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 edge-custom-policy-java-properties.jar apiproxy/resources/java
```

Implantar e chamar o proxy

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

cd para api-platform-samples/doc-samples/java-properties
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 do 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 a nuvem privada do Edge.
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-properties
```
O proxy retorna o cabeçalho: X-PROPERTY-HELLO: WORLD!. Não se esqueça de que adicionamos na política um par de nome/valor de propriedade "prop/WORLD!". A chamada de Java recupera o valor "WORLD!" e o define em um cabeçalho chamado X-PROPERTY-HELLO:
```
messageContext.getMessage().setHeader("X-PROPERTY-HELLO", this.properties.get("prop")); 
```