Usando o script wsadmin com o Jython

Jython é uma implementação alternativa do Python, escrito inteiramente em Java™.

A ferramenta wsadmin usa o Jython V2.7. As informações a seguir são um resumo básico da sintaxe do Jython. Em todo código de amostra, a notação => no início de uma linha representa saída de comando ou função.

Para obter informações adicionais específicas do Jython V2.7, consulte Jython V2.7 behavior changes

Se o Jython V2.1 for necessário, em seguida, você deverá configurá-lo explicitamente, utilizando um dos métodos a seguir:

Nota: Os módulos de biblioteca do Jython são enviados com o binário Jython no WebSphere Application Server Versão 9.0. No entanto, não fornecemos nenhum suporte técnico, se você encontrar problemas com os módulos de biblioteca do Jython. Para os problemas técnicos do Jython, poste a questão no Projeto do Jython.

Função Básica

A função é o nome de uma função interna ou uma função do Jython. Por exemplo, as seguintes funções retornam "Hello, World!" como a saída:

print "Hello, World!"
=> Hello, World!

import sys
sys.stdout.write("Hello World!\n")
=> Hello, World!

No exemplo, print identifica o fluxo de saída padrão. É possível utilizar o módulo interno, executando as instruções de importação, como no exemplo anterior. A importação de instruções executa o código em um módulo, como parte da importação, e retorna o objeto do módulo. sys é um módulo interno da linguagem Python. Na linguagem Python, os módulos são espaços de nomes, que são locais onde os nomes são criados. Os nomes que residem nos módulos são denominados atributos. Os módulos correspondem aos arquivos e a linguagem Python cria um objeto de módulo para conter todos os nomes definidos no arquivo. Em outras palavras, módulos são espaços de nomes.

Evitar Problemas Evitar Problemas: Ao emitir um comando Jython em um script wsadmin que chama uma operação MBean do WebSphere Application Server, e o método MBean retornar uma sequência que inclui alguns caracteres traduzidos do NLS, como o caractere de acento francês, o Jython converte automaticamente a sequência em uma sequência Unicode Python e retorna a sequência convertida em wsadmin. Se você incluir o comando de saída de impressão Jython no script que chama o método MBean, os caracteres traduzidos do NLS serão incluídos na sequência que o método MBean retorna para wsadmin, em vez dos valores Unicode Python. Para evitar a exibição de caracteres traduzidos do NLS, use uma variável para o exemplo de retorno do MBean (por exemplo, output = AdminControl.invoke(mbean)) e, em seguida, use a saída de impressão. Utilize o comando de impressão Jython para converter sequências que contenham caracteres traduzidos do NLS corretamente.gotcha
Evitar Problemas Evitar Problemas: When you issue a Jython command in a wsadmin script that invokes a WebSphere Application Server MBean operation, and the MBean method returns a string that includes some NLS translated characters such as the French accent character, Jython automatically converts the string to a python unicode string, and returns the converted string to wsadmin. If you include the Jython print output command in the script that invokes the MBean method, the NLS translated characters are included in the string that the MBean method returns to wsadmin instead of the python unicode values. To avoid the displaying of NLS translated characters, use a variable for the MBean return (for example, output = AdminControl.invoke(mbean)) and then use print output. Use the Jython print command to convert strings that contain NLS translated characters correctly.gotcha

Variável

Para designar objetos a nomes, o destino de uma designação vai no primeiro lado de um sinal de igual (=) e o objeto que está sendo designado no outro lado. O destino no primeiro lado pode ser um nome ou componente de objeto, e o objeto no outro lado pode ser uma expressão arbitrária que calcula um objeto. As regras a seguir existem para designar objetos a nomes:

  • Designações criam referências do objeto.
  • Nomes são criados quando são designados.
  • É necessário designar um nome antes de referenciá-lo.

As regras de nome de variável são como as regras para a linguagem C; por exemplo, os nomes de variáveis podem ter um caractere de sublinhado (_) ou uma letra mais qualquer número de letras, dígitos ou sublinhados.

As seguintes palavras reservadas não podem ser utilizadas como nomes de variáveis:
  • e
  • assert
  • break
  • class
  • continue
  • def
  • del
  • elif
  • else
  • except
  • exec
  • finally
  • for
  • a partir da
  • global
  • if
  • import
  • entrada
  • é
  • lambda
  • nenhum
  • ou
  • aprovado
  • imprimir
  • raise
  • return
  • try
  • while

Por exemplo:

a  = 5
print a
=> 5

b =  a
print b
=> 5

text1, text2, text3, text4  = 'good', 'bad', 'pretty', 'ugly'
print text3
=> pretty

O segundo exemplo designa o valor da variável a para uma variável b.

Tipos e Operadores

A lista a seguir contém exemplos de tipos de objetos integrados:

  • Números. Por exemplo:
    8, 3.133,  999L,  3+4j
    
    num1 = int(10)
    print num1
    => 10
  • Seqüências. Por exemplo:
    'name',  "name's", ''
    
    print str(12345)
    => '12345'
  • Listas. Por exemplo:
    x = [1, [2,  'free'], 5]
    y = [0, 1, 2, 3]
    y.append(5)
    print y
    => [0, 1, 2, 3, 5]
    
    y.reverse()
    print y
    => [5, 3, 2, 1, 0]
    
    y.sort()
    print y
    => [0, 1, 2, 3, 5]
    
    print list("apple")
    => ['a', 'p', 'p', 'l', 'e']
    
    print list((1,2,3,4,5))
    => [1, 2, 3, 4, 5]
    
    test = "This is a test"
    test.index("test")
    => 10
    
    test.index('s')
    => 3

A lista a seguir contém exemplos de operadores:

  • x ou y

    y é avaliado apenas se x for false. Por exemplo:

    print 0 or 1
    => 1
  • x e y

    y é avaliado apenas se x for true. Por exemplo:

    print 0 and 1
    =>  0
  • x +y , x - y

    Adição e concatenação, subtração. Por exemplo:

    print  6 + 7
    => 13
    
    text1 = 'Something'
    text2 = ' else'
    print text1 + text2
    => Something else
    
    list1 = [0, 1, 2, 3]
    list2 = [4, 5, 6, 7]
    print list1 + list2
    => [0, 1, 2, 3, 4, 5, 6, 7]
    
    print  10 - 5
    => 5
  • x * y, x / y, x % y

    Multiplicação e repetição, divisão, lembrete e formatação. Por exemplo:

    print 5 * 6
    => 30
    
    print 'test' * 3
    => test test test
    
    print 30 / 6
    => 5
    
    print 32 % 6
    => 2
  • x[i], x[i:j], x(...)

    Indexação, corte, chamadas de função. Por exemplo:

    test = "This is a test"
    print  test[3]
    => s 
    
    print test[3:10]
    => s is a
    
    print test[5:]
    => is a test
    
    print test[:-4]
    => This is a print len(test)
    => 14
  • <, <=, >, >=, ==, <>, !=, is is not

    Operadores de comparação, testes de identidade. Por exemplo:

    L1 = [1, ('a', 3)]
    L2 = [1, ('a', 2)]
    L1 < L2, L1 == L2, L1 > L2, L1 <> L2, L1 != L2, L1 is L2, L1 is not L2
    => (0, 0, 1, 1, 1, 0, 1)

Substituição de barra invertida

Se uma instrução tiver que se estender por diversas linhas, também é possível incluir uma barra invertida (\) no final da linha anterior para indicar que você está continuando na próxima linha. Não use caracteres de espaço em branco, especificamente tabs ou espaço, após o caractere de espaço em branco. Por exemplo:

text =  "This is a test of a long lines" \
" continuing lines here."
print text
=> This is a test of a long lines continuing lines here.

Funções e Escopo

O Jython utiliza a instrução def para definir funções. As instruções relacionadas a funções incluem:
  • def, return

    A instrução def cria uma função object e designa-a a um nome. A instrução return envia um objeto de resultado de volta ao responsável pela chamada. Isto é opcional e se não estiver presente, uma função existe de forma que o fluxo de controle fique fora do corpo da função.

  • global

    A instrução global declara as variáveis de nível de módulo que devem ser designadas. Por padrão, todos os nomes designados em uma função são locais para essa função e existem apenas enquanto a função está em execução. Para designar um nome no módulo de fechamento, liste as funções em uma instrução global.

A sintaxe básica para definir uma função é a seguinte:

def name (arg1, arg2, ... ArgN)
   statements
   return value

em que name é o nome da função que está sendo definida. Ele é seguido por um parênteses de abertura, um parêntese de fechamento e um ponto-e-vírgula. Os argumentos dentro dos parênteses incluem uma lista de parâmetros para os procedimentos. A próxima linha após os dois pontos é o corpo da função. Um grupo de comandos que formam o corpo da função. Assim que você define uma funçãoJython, ela é usada como qualquer outra das funções integradas. Por exemplo:

def intersect(seq1, seq2):
   res = []
   try:
      for x in seq1:
         if x in seq2:
            res.append(x)
   except:
      aprovado
   return res

Para chamar esta função, utilize o seguinte comando:

s1 = "SPAM"
s2 = "SCAM"
intersect(s1, s2)
=> [S, A, M]

intersect([1,2,3], (1.4)) 
=> [1]

Comments

Faça comentários na linguagem Jython com o caractere sustenido (#).

Argumentos da Linha de Comandos

As shells Jython passam os argumentos de linha de comandos para o script como o valor do sys.argv. No Jython wsadmin, o nome do programa ou script não faz parte de sys.argv. Deferente de wsadmin Jython, o Jython independente toma o arquivo de script como o argumento inicial para o script. Como sys.argv é uma matriz, utilize o comando de indexação para extrair itens de uma lista de argumentos. Por exemplo, test.py toma três argumentos a, b e c.

wsadmin -f test.py  a  b  c

test.py content:

import sys
first  =  sys.argv[0]
second  = sys.argv[1]
third = sys.argv[2]
arglen = len(sys.argv)

Instruções Básicas

Há duas instruções de loop: while e for. A instrução condicional é if. A instrução de manipulação de erros é try. Finalmente, há algumas instruções para ajustar o fluxo de controle: break, continue e pass.

if

A instrução if seleciona ações a serem executadas. A instrução if pode conter outras instruções, incluindo outras instruções if. A instrução if pode ser seguida por uma ou mais instruções opcionais elif e finaliza com um bloco opcional else.

O formato geral de um if tem a seguinte aparência:

if test1
   statements1
elif test2
   statements2
else
   statements3

Por exemplo:

weather = 'sunny'
if weather == 'sunny':
   print "Nice weather"
elif weather == 'raining':
   print "Bad weather"
else:
   print "Uncertain, don't plan anything"
while

A instrução while consiste em uma linha de cabeçalho com uma expressão de teste, um corpo de uma ou mais instruções recuadas e uma instrução opcional else, que é executada se o controle sair do loop sem executar uma instrução break. A instrução while executa repetidamente um bloco de instruções indentadas, enquanto um teste na linha de cabeçalho mantém a avaliação de um valor true. Um exemplo de while é mostrado a seguir:

while test1
   statements1
else
   statements2

Por exemplo:

a = 0; b = 10
while a < b:
   print a
   a = a + 1
por

A instrução for é iniciada com uma linha de cabeçalho que especifica um destino ou destinos de designação, juntamente com um objeto que você deseja inserir. O cabeçalho é seguido de um bloco de instruções recuadas que você deseja repetir.

Um exemplo de uma instrução for é mostrado a seguir:

for target in object:
   statements
else:
   statements

Designa itens no objeto de sequência para o destino, um por um, e executa o corpo de loop para cada um. O corpo de loop geralmente utiliza o destino de designação para referir-se ao item atual na seqüência como se houvesse um cursor passando pela seqüência. Por exemplo:

sum = 0
for x in [1, 2, 3, 4]:
   sum = sum + x
break, continue e pass

É possível controlar loops com as instruções break, continue e pass. A instrução break ignora o loop de fechamento mais próximo (passa por toda a instrução de loop). A instrução continue vai para o início do loop de fechamento mais próximo (para a linha de cabeçalho do loop), e a instrução pass é um item temporário da instrução vazia.

try

Uma instrução mostrará um erro se chamada com o número errado de argumentos ou se detectar alguma condição de erro particular na implementação. Um erro não detectado para a execução de um script. A instrução try é usada para conter tais erros. As instruções try de Python vêm de duas maneiras, uma que manipula exceções e uma que executa o código de finalização se ocorrerem ou não exceções. As instruções try, except, else são iniciadas com uma linha de cabeçalho try, seguida de um bloco de instruções recuadas e, em seguida, uma ou mais cláusulas de exceção opcionais que nomeiam as exceções a serem detectadas e uma cláusula opcional else no final. As instruções try, finally iniciam com uma linha de cabeçalho try seguida por um bloco de instruções indentadas e, em seguida, a cláusula finally que sempre é executada na saída se tiver ocorrido uma exceção durante a execução ou não do bloco try.

Um exemplo das funções try, except, else é mostrado a seguir:

try:
   statements
except name:
   statements
except name, data:
   statements
else
   statements

Por exemplo:

try: myfunction() except: import sys print 'uncaught exception', sys.exc_info() try: myfilereader() except EOFError: break else: process next line here

O formato geral de try e finally tem a seguinte aparência:

try
   statements
finally
   statements

Por exemplo:

def divide(x, y):
   return x / y

def tester(y):
   try:
      print divide(8, y)
   finally:
      print 'on the way out...'
A seguir está uma lista de regras de sintaxe em Python:
  • As instruções são executadas sequencialmente, por padrão. As instruções normalmente terminam no final da linha na qual elas aparecem. Quando as instruções são muito longas para caber em uma única linha, você também pode incluir uma barra invertida (\) no final da linha anterior para indicar que está continuando na próxima linha.
  • Bloqueios e limites de instrução são detectados automaticamente. Não há chaves ou delimitadores de início e final entre blocos de código. Em vez disso, a linguagem Python utiliza um recuo de instruções sob um cabeçalho para agrupar as instruções em um bloco aninhado. Os limites de blocos são detectados pelo recuo da linha. Todas as instruções que indentaram a mesma distância pertencem ao mesmo bloco de código, até que o bloco seja terminado por uma linha menos indentada.
  • Instruções compostas = cabeçalho; ':', instruções recuadas. Todas as instruções compostas na linguagem Python seguem o mesmo padrão: uma linha de cabeçalho finalizada com uma vírgula, seguida de uma ou mais instruções aninhadas, recuadas sob o cabeçalho. As instruções recuadas são chamadas de bloco.
  • Os espaços e os comentários são geralmente ignorados. Os espaços nas instruções e expressões são quase sempre ignorados (exceto nas constantes e recuos de cadeias), assim como os comentários.

Chamando Scripts Utilizando um Outro Script

Utilize o comando execfile para chamar um script Jython a partir de um outro script Jython. Por exemplo:

Crie um script chamado test1.py que contenha o seguinte:

[AIX Solaris HP-UX Linux Windows]
execfile('c:/temp/script/testFunctions.py')
print printName('Cathy', 'Smith')
[z/OS]
execfile('/temp/script/testFunctions.py')
print printName('Cathy', 'Smith')

Crie um script chamado testFunctions.py que contenha o seguinte:

def printName(first, last):
   name = first + ' ' + last
   return name

Em seguida, transmita o seguinte caminho como um argumento do script:

[AIX Solaris HP-UX Linux Windows]
wsadmin -lang jython -f 'c:/temp/script/test1.py'
[z/OS]
wsadmin -lang jython -f '/temp/script/test1.py'

Você deve utilizar barras (/) como separador de caminho. Barras invertidas (\) não funcionam.

Executando Scripts Jython que Usam Pacotes

Se executar scripts que usam pacotes, você deve fornecer à ferramenta wsadmin o caminho da procura para scripts Jython que usam pacotes.

Para fornecer estas informações à ferramenta wsadmin, inclua a opção a seguir ao iniciar a ferramenta:

-Dwsadmin.script.libraries.packages=path1;path2;...

em que dir1 e dir2 representam os caminhos de procura de diretório para bibliotecas que contêm os pacotes Jython.

[Windows]

Uso do Jython com diretórios do Microsoft Windows

O Jython trata a lista de caracteres ou as condições a seguir como especiais. Não utilize os caracteres, se possível, ao utilizar Jython.

  • \a
  • \b
  • \f
  • \n
  • \N
  • \r
  • \t
  • \u
  • \U
  • \v
  • \x
  • uma barra invertida seguida por uma sequência de números entre 0 e 7

Quando especificar caminhos de arquivo do Microsoft Windows no Jython, você deve tomar ciência dessas condições especiais. Quando você tiver que usar qualquer uma dessas cadeias de caracteres, poderá interferir na interpretação Jython dessas cadeias de caracteres especiais usando "duas barras invertidas" em vez de apenas uma barra invertida ou substituindo uma barra por uma barra invertida única. Os exemplos a seguir ilustram como fazer esses ajustes.

Tabela 1. Especificações de Caminho de Arquivo do Jython. Utilize \\ ou / como separadores de diretório em caminhos de arquivos Windows.
Caminho Errôneo Caminho Corrigido com Duas Barras Invetidas Caminho Corrigido com Barra
c:\aadirectory\myfile.txt c:\\aadirectory\\myfile.txt c:/aadirectory/myfile.txt
c:\myfiles\number1.txt c:\\myfiles\\number1.txt c:/myfiles/number1.txt
c:\zebra7\stripe.txt c:\zebra7\\stripe.txt c:/zebra7/stripe.txt
c:\5mod\Net33\residue.log c:\\fivemod\\Net33\\residue.log c:/fivemod/Net33/residue.log
Evitar Problemas Evitar Problemas: Em geral, tente usar a barra onde possível ao especificar os caminhos de diretório no Jython. A barra evita muitos problemas associados ao uso das barras invertidas.gotcha

Ícone que indica o tipo de tópico Tópico de Conceito



Ícone de registro de data e hora Última atualização: last_date
http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=cxml_jython
Nome do arquivo: cxml_jython.html