Bắt đầu với IBM Websphere smash - p 12 docx

zdelete Method To remove a list from the global context, we use zdelete: boolean zdeleteString location [, boolean deleteChildren ]; The zdelete method deletes the specified location, rem

zdelete Method

To remove a list from the global context, we use zdelete:

boolean zdelete(String location [, boolean deleteChildren ]);

The zdelete method deletes the specified location, removing any values stored there (see

Listing 5.15)

Listing 5.15 zdelete a List

GlobalContext.zdelete("/app/stringList");

GlobalContext.zdelete("/app/integerList");

Here we delete both of the lists we’ve previously created and updated The optional

deleteChildren parameter works the same as the object usage of this method As with zput, we

can delete single elements from our list by specifying the #<key> in the location (see Listing 5.16)

Listing 5.16 zdelete a List Element

GlobalContext.zdelete("/app/stringList#0");

GlobalContext.zdelete("/app/integerList#1");

The first zdelete removes the first element of the string list, and the second zdelete

removes the second element of the integer list Sometimes code requires that a particular list be

available before executing We can test the availability of a list by using the zcontains method,

the same way we do for objects

zcontains Method

To test if a list is in the global context, we use the zcontains method:

boolean zcontains(String location);

The zcontains method returns a boolean value, indicating whether the particular list is

available in the global context (see Listing 5.17)

Listing 5.17 The zcontains Method for a List

if(GlobalContext.zcontains("/app/stringList")

{

//do something

}

The zcontains method can be used as a guard code that must have particular lists

avail-able Like other list operations, the zcontains method can access particular elements of a list by

using the #<key> notation (see Listing 5.18)

Listing 5.18 The zcontains Method for a List Element

if(GlobalContext.zcontains("/app/stringList#0")

{

//do something

}

This code tests to be sure that the first element in the string list exists before executing some

code The rest of the global context methods (zlist, zlistAll, and zdump) work the same as

they do with objects

FirstElementLists

FirstElementLists work very much the same as lists in many cases However, the first

ele-ment is operated on by default The general idea is that these lists operate like stacks You would

normally be operating only on the head of the list, which with a first element list is found at

"<zone or locationPrefix>/list" instead of at "<zone or locationPrefix>/list#0"

with a normal list

zput Method

To put a FirstElementList into the global context, we use the zput method:

boolean zput(String location, List list);

The zput method places the FirstElementList in the particular global context location

(see Listing 5.19)

Listing 5.19 Creating a FirstElementArrayList

FirstElementArrayList list = new FirstElementArrayList<String>();

list.add("some string");

list.add("string object");

GlobalContext.zput("/tmp/list#*", list);

The FirstElementArrayList is available in the zero.util package With this code, we’ve

created a list and then used zput to create or replace the list in the tmp zone so that we can use it

later during the course of our application execution Notice that with FirstElementLists, we

must use the #* notation to indicate that we’d like to use a FirstElementList We can replace

single elements of our stored list by using #<key> to specify where to put the value:

GlobalContext.zput("/tmp/list#1", "new string");

This replaces "string object" with "new string" in our stored list To replace the first

item in the list, we don’t need to use the #<key> We simply need to use the location:

GlobalContext.zput("/tmp/list", "new first item");

This replaces the first item in the list If we need to add to a list, we must use the zpost

method

zpost Method

To append to a FirstElementList in the global context, we use the zpost method:

boolean zpost(String location, Object object);

The zpost method appends the FirstElementList to the list stored at the given

loca-tion (see Listing 5.20)

Listing 5.20 Using zpost to Append to a FirstElementList

FirstElementArrayList list = new FirstElementArrayList ();

GlobalContext.zpost("/tmp/list#*", list);

GlobalContext.zpost("/tmp/list", "posted string object");

Here we’ve created an empty list and then posted a single element into the list This method

can also be used to append a list to another list (see Listing 5.21)

Listing 5.21 Using zpost to Append a List to a FirstElementList

FirstElementArrayList list = new FirstElementArrayList ();

GlobalContext.zput("/tmp/list/#*", list);

GlobalContext.zpost("/tmp/list", "posted string object");

list.add("string object");

GlobalContext.zpost("/tmp/list#*", list);

In this case, we’ve created an empty list and posted an element to the list stored in the tmp

zone Next, we add some elements to the Java list and then append them to the stored list using a

zpost If we have several lists that we’d like to place in the global context, we can use the zputs

method just like we did with objects

zputs Method

To append to a FirstElementList in the global context, we use the zpost method:

Map zputs(String location, Map lists);

This is another convenient method to place several lists into the global context at once (see

Listing 5.22)

Listing 5.22 Using zputs to Put Multiple Lists into the Global Context

FirstElementArrayList slist = new ArrayList();

slist.add("string one");

slist.add("string two");

FirstElementArrayList ilist = new ArrayList();

ilist.add(new Integer(1));

ilist.add(new Integer(2));

Map map = new HashMap();

map.put("stringList#*", slist);

map.put("integerList#*", ilist);

GlobalContext.zputs("/app", map);

The zputs method places two variables containing the lists into the app zone:

/app/stringList with the contents of slist and /app/integerList with the contents of

ilist

zget Method

To retrieve variables placed in the global context, we use the zget method:

Object zget(String location [, Object defaultValue ]);

The zget method retrieves the list in the particular global context location Optionally, you

can provide a default value for the list being retrieved If a default is not provided and the location

is not found, a null is returned (see Listing 5.23)

Listing 5.23 zget of a FirstElementList

List slist = GlobalContext.zget("/app/stringList#*", new ArrayList());

List ilist = GlobalContext.zget("/app/integerList#*");

Here we are retrieving our string list with a default empty ArrayList and our integer list

with no default We can also retrieve individual elements from our list by again using the #<key>

notation (see Listing 5.24)

Listing 5.24 zget of the First Element of a FirstElementList

String s = GlobalContext.zget("/app/stringList");

Integer i = GlobalContext.zget("/app/integerList");

This code retrieves the first element of each list It is possible to retrieve the Nth item in the

list as well, using the #<key> notation (see Listing 5.25)

Listing 5.25 zget of an Element from a FirstElementList

String s = GlobalContext.zget("/app/stringList#1");

Integer i = GlobalContext.zget("/app/integerList#2");

This code retrieves the second item in the string list and the third item in the integer list

zdelete Method

To remove a list from the global context, we use zdelete:

boolean zdelete(String location [, boolean deleteChildren ]);

The zdelete method deletes the specified location, removing any values stored there (see

Listing 5.26)

Listing 5.26 zdelete of a FirstElementList

GlobalContext.zdelete("/app/stringList#*");

GlobalContext.zdelete("/app/integerList#*");

Here we delete both of the lists we’ve previously created and updated The optional

deleteChildren parameter works the same as the object usage of this method As with zput, we

can delete single elements from our list by specifying the #<key> in the location (see Listing 5.27)

Listing 5.27 zdelete of an Element of a FirstElementList

GlobalContext.zdelete("/app/stringList");

GlobalContext.zdelete("/app/integerList#1");

The first zdelete removes the first element of the string list, and the second zdelete

removes the second element of the integer list Sometimes code requires that a particular list be

available before executing We can test the availability of a list by using the zcontains method,

the same way we do for objects

zcontains Method

To test if a list is in the global context, we use the zcontains method:

boolean zcontains(String location);

The zcontains method returns a boolean value indicating whether the particular list is

available in the global context (see Listing 5.28)

Listing 5.28 zcontains of a FirstElementList

if(GlobalContext.zcontains("/app/stringList#*")

{

//do something

}

The zcontains method can be used as a guard code that must have particular lists

avail-able With FirstElementLists, we can test the first existence of the first by directly accessing

the variable (see Listing 5.29)

Listing 5.29 zcontains of the First Element of a FirstElementList

if(GlobalContext.zcontains("/app/stringList")

{

//do something

}

This code tests to verify that the first element in the list exists before executing code We

can test other elements in the list using the #<key> notation (see Listing 5.30)

Listing 5.30 zcontains of an Element from a FirstElementList

if(GlobalContext.zcontains("/app/stringList#1")

{

//do something

}

This code tests to see whether the second element in the list exists The rest of the global

context methods (zlist, zlistAll, and zdump) work the same as they do with lists and objects

Maps

Maps are lists of key/value pairs To put a single map into the global context, we use the zput

method

zput Method

To put a map into the global context, we use the zput method:

boolean zput(String location, Map map);

The zput method places the object in the particular global context location (see Listing 5.31)

Listing 5.31 zput of a Map

HashMap map = new HashMap();

map.put("integer",new Integer(42));

map.put("string", "string object");

GlobalContext.zput("/tmp/map", map);

With this code, we’ve created a map and then used zput to create or replace the map in the

tmp zone This way, we can use it at a later time during the course of our application execution We

can replace single elements of our stored map by using #<key> to specify where to put the value:

GlobalContext.zput("/tmp/map#string", "new string");

This replaces "string object" with "new string" in our stored map We can also use

zput to add to a map:

GlobalContext.zput("/tmp/map#foo", "added foo");

zpost Method

If we need to merge two maps, we must use the zpost method:

boolean zpost(String location, Map map);

The zpost method appends the object to the map stored at the given location (see Listing 5.32)

Listing 5.32 zpost an Append to a Map

HashMap map = new HashMap();

map.put("foo", "foo value");

GlobalContext.zpost("/tmp/map", map);

map = new HashMap();

map.put("bar", "bar value");

GlobalContext.zpost("/tmp/map", map);

Here we create a map and place a single key/value pair into it Then we create another new

map with another key/value pair Finally, we use zpost to merge the maps in the tmp zone If we

have several maps that we’d like to place in the global context, we can use the zputs method just

like we did in the “Lists” section

zputs Method

To put several maps into the global context, we use the zputs method:

Map zputs(String location, Map maps);

This is another convenient method to place several maps into the global context at once (see

Listing 5.33)

Listing 5.33 zputs Several Maps into the Global Context

HashMap smap = new HashMap();

smap.add("one", "string one");

smap.add("two", "string two");

HashMap imap = new HashMap();

imap.add("one", new Integer(1));

imap.add("two", new Integer(2));

HashMap map = new HashMap();

map.put("stringMap", smap);

map.put("integerMap", imap);

GlobalContext.zputs("/app", map);

The zputs method places two variables containing the maps into the app zone: /app/

stringMap with the contents of smap and /app/integerMap with the contents of imap

zget Method

To retrieve variables placed in the global context, we use the zget method:

Object zget(String location [, Object defaultValue ]);

The zget method retrieves the map in the particular global context location Optionally,

you can provide a default value for the map being retrieved If a default is not provided and the

location is not found, a null is returned (see Listing 5.34)

Listing 5.34 zget a Map

Map smap = GlobalContext.zget("/app/stringMap", new HashMap());

Map imap = GlobalContext.zget("/app/integerMap");

Here we are retrieving our string map with a default empty HashMap and our integer map

with no default We can also retrieve individual elements from our map by again using the

#<key> notation (see Listing 5.35)

Listing 5.35 zget a Map Value

String s = GlobalContext.zget("/app/stringMap#foo");

Integer i = GlobalContext.zget("/app/integerMap#one");

This code retrieves the specified value element of each map that corresponds to the given

key To remove a map from the global context, we use zdelete

zdelete Method

To remove a map the global context, we use the zdelete method:

boolean zdelete(String location [, boolean deleteChildren ]);

The zdelete method deletes the specified location, removing any values stored there (see

Listing 5.36)

Listing 5.36 zdelete a Map

GlobalContext.zdelete("/app/stringMap");

GlobalContext.zdelete("/app/integerMap");

Here we delete both of the maps we’ve previously created and updated The optional

deleteChildren parameter works the same as the object usage of this method As with zput, we

can delete single elements from our map by specifying the #<key> in the location (see Listing 5.37)

Listing 5.37 zdelete a Map Value

GlobalContext.zdelete("/app/stringMap#foo");

GlobalContext.zdelete("/app/integerMap#one");

The first zdelete removes the element with the "foo" key from the string map, and the

second zdelete removes the element with the "one" key from the integer map Sometimes

code requires that a particular map be available before executing We can test the availability of a

map by again using the zcontains method, the same way we do for objects

zcontains Method

To test if a map is in the global context, we use the zcontains method:

boolean zcontains(String location);

The zcontains method returns a boolean value indicating if the particular map is

avail-able in the global context (see Listing 5.38)

Listing 5.38 zcontains a Map

if(GlobalContext.zcontains("/app/stringMap")

{

//do something

}

The zcontains method can be used as a guard code that needs to have particular maps

available Like other map operations, the zcontains method can access particular elements of a

map by using the #<key> notation (see Listing 5.39)

Listing 5.39 zcontains a Map Value

if(GlobalContext.zcontains("/app/stringMap#foo")

{

//do something

}

This code tests to be sure that the "foo" element in the map exists before executing code The

rest of the global context methods (zlist, zlistAll, and zdump) work as they do with objects

Groovy APIs

To access the global context in Groovy, you can use the same APIs as presented in the Java

sec-tion, but there are shortcuts in Groovy to aid access In this secsec-tion, we show you these shortcuts

Please refer to the previous Java API section for complete explanations of the Java APIs

Objects

zput Method

The Java zput method places objects into the global context:

boolean zput(String location, Object object);

The Groovy version of this API is simply an assignment to the location for the particular

context In other words, you can address the global context directly in Groovy as if it were a

vari-able in your Groovy script (see Listing 5.40)

Listing 5.40 Placing Groovy Variables into the Global Context

app.string = "string object"

app.integer = 42

In these two lines of code, we’ve created or replaced a string object and an integer object in

the app zone so that we can use it at a later time To retrieve variables placed in the global context,

we use the zget method in Java

zget Method

The zget method retrieves the object in the particular global context location In Groovy, we use

the following to directly retrieve objects in the global context (see Listing 5.41)

Listing 5.41 Retrieving Variables from the Global Context with Groovy

var s = app.string[]

var i = app.integer[]

Here we are retrieving a string object and an integer object

zdelete Method

To remove variables from the global context, we use zdelete in Groovy just like we do in Java

Please refer to the previous section on Java

zcontains Method

In Java, to test if a variable exists in the global context, we’d use the zcontains method

How-ever, because we access the global context directly in Groovy, we can test the availability of a

variable in a natural way (see Listing 5.42)