Utilisation des scripts de wsadmin avec Jython
Le langage Jython est une implémentation de remplacement du langage Python. Il est écrit entièrement en Java™.
L'outil wsadmin utilise le langage Jython version 2.7. Les informations ci-après résument la syntaxe Jython. Dans tout le code exemple, la notation => au début d'une ligne représente la sortie d'une commande ou d'une fonction.
Pour des informations supplémentaires sur le langage Jython version 2.7, voir Jython V2.7 behavior changes.
Si Jython version 2.1 est requis, vous devez le configurer explicitement en utilisant l'une des méthodes suivantes :
- Spécifiez Jython version 2.1 à l'aide de la commande wsadmin suivante :
wsadmin -conntype soap -usejython21 true -f test.py
- Spécifiez Jython version 2.1 à l'aide d'une propriété personnalisée dans le fichier wsadmin.properties :
com.ibm.ws.scripting.usejython21=true
La valeur par défaut est false.
Fonction de base
La fonction correspond soit au nom d'une fonction intégrée, soit au nom d'une fonction Jython. Par exemple, les fonctions ci-après renvoient la sortie "Hello, World!" :
print "Hello, World!"
=>Hello, World!
import sys
sys.stdout.write("Hello World!\n")
=>Hello, World!
Dans l'exemple, print identifie le flux de sortie standard. Vous pouvez utiliser le module intégré en exécutant des instructions d'importation comme dans l'exemple précédent. L'importation de l'instruction exécute le code dans un module qui fait partie de l'importation et renvoie l'objet du module. sys est un module intégré du langage Python. Dans le langage Python, les modules sont des espaces de nom dans lesquels les noms sont créés. Les noms qui se trouvent dans les modules sont des attributs. Les modules correspondent aux fichiers. Le langage Python crée un objet de module destiné à contenir tous les noms définis dans le fichier. En d'autres termes, les modules sont des espaces de nom.


Variable
Pour affecter des objets à des noms, la cible d'une affectation va à gauche du signe égal (=) et l'objet que vous affectez à droite. La cible à gauche peut être un nom ou un composant d'objet. L'objet à droite peut être une expression arbitraire qui calcule un objet. Il existe des règles pour affecter des objets à des noms :
- Les affectations créent des références d'objet.
- Les noms sont créés lorsque vous les affectez.
- Vous devez affecter un nom avant de le référencer.
Les règles de nom de variable sont identiques aux règles du langage C. Par exemple, les noms de variable peuvent contenir le caractère de soulignement (_) ou une lettre plus n'importe quel nombre de lettres, de chiffres ou de caractères de soulignement.
- et
- assert
- break
- class
- continue
- def
- del
- elif
- else
- except
- exec
- finally
- for
- from
- global
- if
- import
- in
- is
- lambda
- not
- ou
- pass
- raise
- return
- try
- while
Par exemple :
a = 5
print a
=> 5
b = a
print b
=> 5
text1, text2, text3, text4 = 'good', 'bad', 'pretty', 'ugly'
print text3
=> pretty
Le second exemple affecte la valeur d'une variable a à une variable b.
Types et opérateurs
La liste ci-dessous contient des exemples de types d'objet intégré :
- Numéros. Par exemple :
8, 3.133, 999L, 3+4j num1 = int(10) print num1 => 10
- Chaînes. Exemple :
'name', "name's", '' print str(12345) => '12345'
- Listes. Exemple :
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
La liste ci-dessous contient des exemples d'opérateurs :
- x or y
y est évalué uniquement si x est faux. Exemple :
print 0 or 1 => 1
- x and y
y est évalué uniquement si x est vrai. Exemple :
print 0 and 1 => 0
- x +y , x - y
Addition et concaténation, soustraction. Exemple :
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
Multiplication et répétition, division, reste et format. Exemple :
print 5 * 6 => 30 print 'test' * 3 => test test test print 30 / 6 => 5 print 32 % 6 => 2
- x[i], x[i:j], x(...)
Indexation, découpage, appels de fonction. Exemple :
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
Opérateurs de comparaison, tests d'identité. Exemple :
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)
Remplacement de barre oblique inversée
Si une instruction doit s'étendre sur plusieurs lignes, vous pouvez également ajouter une barre oblique inversée (\) à la fin de la ligne précédente pour indiquer que vous continuez sur la ligne suivante. N'utilisez aucun espace (ni tabulation ou espace) après la barre oblique inversée. Exemple :
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.
Fonctions et portée
- def, return
L'instruction def crée une fonction object et l'affecte à un nom. L'instruction return envoie un objet result au programme qui émet l'appel. Cette instruction est facultative. En son absence, il existe une fonction pour que le flux de contrôle découle du corps de la fonction.
- global
L'instruction global déclare des variables de niveau de module à affecter. Par défaut, tous les noms affectés dans une fonction sont locaux pour la fonction. Ils n'existent que lorsque la fonction est en cours d'exécution. Pour affecter un nom au module, répertoriez les fonctions dans une instruction générale.
La syntaxe de base permettant de définir une fonction est la suivante :
def name (arg1, arg2, ... ArgN)
statements
return value
où nom est le nom de la fonction définie. Elle est suivie d'une parenthèse ouvrante, d'une parenthèse fermante et des deux-points (:). Les arguments entre parenthèses incluent une liste de paramètres dans les procédures. La ligne suivante après les deux points est le corps de la fonction. Un groupe de commandes qui forme la partie de la fonction. Une fois une fonction Jython définie, elle est utilisée comme n'importe quelle autre fonction intégrée. Exemple :
def intersect(seq1, seq2):
res = []
try:
for x in seq1:
if x in seq2:
res.append(x)
except:
pass
return res
Pour appeler cette fonction, utilisez la commande suivante :
s1 = "SPAM"
s2 = "SCAM"
intersect(s1, s2)
=> [S, A, M]
intersect([1,2,3], (1.4))
=> [1]
Commentaires
Utilisez le caractère # pour insérer des commentaires en langage Jython.
Arguments de ligne de commande
Les shells Jython transmettent les arguments de ligne de commande au script en tant que valeur de sys.argv. Dans Jython wsadmin, le nom du programme, ou le script, ne font pas partie de sys.argv. A la différence de Jython wsadmin, Jython autonome accepte le fichier de script comme l'argument initial du script. sys.argv étant un tableau, utilisez la commande index pour extraire des arguments de la liste. Par exemple, test.py accepte trois arguments, a, b et 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)
Instructions de base
Il existe deux instructions en boucle : while et for. L'instruction conditionnelle est if. L'instruction de traitement des erreurs est try. Enfin, il existe des instructions pour ajuster le flux de contrôle : break, continue et pass.
- if
L'instruction if sélectionne les actions à réaliser. L'instruction if peut contenir d'autres instructions, notamment d'autres instructions if. L'instruction if peut être suivie d'une ou de plusieurs instructions facultatives elif et se termine par un bloc facultatif else.
Le format général d'une instruction if est le suivant :
if test1 statements1 elif test2 statements2 else statements3
Exemple :
weather = 'sunny' if weather == 'sunny': print "Nice weather" elif weather == 'raining': print "Bad weather" else: print "Uncertain, don't plan anything"
- while
L'instruction while comprend une ligne d'en-tête avec une expression de test, une partie contenant une ou plusieurs instructions en retrait et une instruction facultative else exécutée si le contrôle quitte la boucle sans s'exécuter dans une instruction break. L'instruction while exécute de manière répétée un bloc d'instructions en retrait tant qu'un test au début évalue si une valeur est vraie. Voici un exemple d'utilisation de while :
while test1 statements1 else statements2
Exemple :
a = 0; b = 10 while a < b: print a a = a + 1
- for
L'instruction for commence par une ligne d'en-tête qui spécifie une ou plusieurs cibles d'affectation, ainsi qu'un objet à parcourir. L'en-tête est suivi d'un bloc d'instructions en retrait à répéter.
Voici un exemple d'utilisation de l'instruction for :
for target in object: statements else: statements
Les éléments sont affectés dans l'objet de séquence pour la cible, un par un, et sont exécutés dans la partie de boucle pour chacun. La partie de boucle utilise généralement la cible d'affectation pour faire référence à l'élément en cours dans la séquence comme s'il s'agissait d'un curseur parcourant la séquence. Exemple :
sum = 0 for x in [1, 2, 3, 4]: sum = sum + x
- break, continue et pass
Vous pouvez contrôler les boucles à l'aide des instructions break, continue et pass. L'instruction break passe à la boucle la plus proche (au-delà de l'instruction de boucle entière). L'instruction continue passe au début de la boucle la plus proche (ligne d'en-tête de la boucle) et l'instruction pass est un espace réservé d'instruction vide.
- try
Une instruction génère une erreur si elle est appelée avec un nombre d'arguments incorrect ou si une condition d'erreur particulière est détectée dans son implémentation. Une erreur non interceptée arrête l'exécution d'un script. L'instruction try permet d'intercepter ces erreurs. Les instructions Python try ont deux variantes, une qui gère les exceptions et une autre qui exécute le code de finalisation, que des exceptions se produisent ou non. Les instructions try, except, else commencent par une ligne d'en-tête try suivie d'un bloc d'instructions en retrait, puis d'une ou de plusieurs clauses d'exception facultatives désignant les exceptions à intercepter et une clause else facultative à la fin. Les instructions try, finally commencent par une ligne d'en-tête try suivie d'un bloc d'instructions en retrait, puis d'une clause finally qui s'exécute toujours, que des exceptions se soient produites ou non et que le bloc try était en cours d'exécution ou non.
Voici un exemple d'utilisation des fonctions try, except et else :
try: statements except name: statements except name, data: statements else statements
Exemple :
try: myfunction() except: import sys print 'uncaught exception', sys.exc_info() try: myfilereader() except EOFError: break else: process next line here
Le format général des instructions try et finally est le suivant :
try statements finally statements
Exemple :
def divide(x, y): return x / y def tester(y): try: print divide(8, y) finally: print 'on the way out...'
- Par défaut, les instructions sont exécutées de manière séquentielle. Les instructions se terminent normalement à la fin de la ligne sur laquelle elles figurent. Lorsque les instructions sont trop longues pour tenir sur une seule ligne, vous pouvez également ajouter une barre oblique inversée (\) à la fin de la ligne précédente pour indiquer que vous continuez sur la ligne suivante.
- Les limites des blocs et des instructions sont détectées automatiquement. Il n'y a pas d'accolades, de délimiteur de début ou de fin, avant et après les blocs de code. Au lieu de cela, le langage Python utilise le retrait pour les instructions sous un en-tête afin de regrouper les instructions dans un bloc imbriqué. Les limites des blocs sont détectées grâce au retrait des lignes. Toutes les instructions observant le même retrait à la même distance appartiennent au même bloc de code jusqu'à ce que ce bloc soit terminé par une ligne ayant un retrait moindre.
- Instructions composées : en-tête; ':', instructions en retrait. Toutes les instructions en retrait dans le langage Python suivent le même modèle : une ligne d'en-tête terminée par deux points (:), suivie d'une ou de plusieurs instructions imbriquées sous l'en-tête. Les instructions en retrait sont appelées des blocs.
- Les espaces et les commentaires sont généralement ignorés. Les espaces à l'intérieur des instructions et des expressions sont pratiquement toujours ignorés (sauf dans les constantes de chaîne et les retraits), tout comme les commentaires.
Appel de scripts à l'aide d'un autre script
Utilisez la commande execfile pour appeler un script Jython à partir d'un autre. Par exemple :
Créez le script test1.py contenant ce qui suit :
![[AIX Solaris HP-UX Linux Windows]](../images/dist.gif)
execfile('c:/temp/script/testFunctions.py')
print printName('Cathy', 'Smith')
![[z/OS]](../images/ngzos.gif)
execfile('/temp/script/testFunctions.py')
print printName('Cathy', 'Smith')
Créez un fichier appelé testFunctions.py contenant ce qui suit :
def printName(first, last):
name = first + ' ' + last
return name
Passez ensuite le chemin d'accès comme argument de script :
![[AIX Solaris HP-UX Linux Windows]](../images/dist.gif)
wsadmin -lang jython -f 'c:/temp/script/test1.py'
![[z/OS]](../images/ngzos.gif)
wsadmin -lang jython -f '/temp/script/test1.py'
Vous devez utiliser des barres obliques (/) comme séparateur de chemin. Les barres obliques inversées (\) ne fonctionnent pas.
Exécution de scripts Jython qui utilisent des packages
Si vous exécutez des scripts qui utilisent des packages, vous devez fournir à l'outil wsadmin le chemin de recherche des scripts Jython qui utilisent ces packages.
Pour fournir ces informations à l'outil wsadmin, incluez l'option suivante lorsque vous lancez l'outil :
-Dwsadmin.script.libraries.packages=path1;path2;...
où path1 et path2 représentent les chemins de recherche de répertoire des bibliothèques contenant les packages Jython.
![[Windows]](../images/windows.gif)
Utilisation de Jython avec les répertoires Microsoft Windows
Pour Jython, les conditions et les caractères suivants sont spéciaux. Dans la mesure du possible, évitez d'utiliser ces caractères avec Jython.
- \a
- \b
- \f
- \n
- \N
- \r
- \t
- \u
- \U
- \v
- \x
- Une barre oblique inversée suivie d'une séquence de chiffres compris entre 0 et 7
Lorsque de la spécification de chemins d'accès Microsoft Windows dans Jython, vous devez connaître ces conditions particulières. Lorsque vous devez utiliser l'une de ces chaînes de caractères, vous pouvez neutraliser l'interprétation par Jython de ces chaînes de caractères spéciales en utilisant "deux barres obliques inversées" au lieu d'une seule ou en remplaçant une barre oblique inversée par une barre oblique. Les exemples suivants illustrent ces réglages.
Chemin d'accès erroné | Chemin d'accès avec double barre oblique inversée corrigé | Chemin d'accès avec barre oblique corrigée |
---|---|---|
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 |
