Scope of instance variables clarification requested

under the topic "Scope of instance variables" in the class notes for the course i'm doing it is stated:
inside the class definition, the name can be prefixed by the keyword "this".
e.g. available = this.balance + overdraft;
in simple words, please explain what it means
or:
what is a class definition? and what does using "this" mean?
i'll gladly take internet links on where i can find the answer to my own question if you don't have time.
thanks a million!

this can be regarded simply as a reference variable which points to the intance of the class it's used in.
So this.fieldOne referer to the instance field fieldOne withing the current instance just as theOther.fieldOne refers to the instance field in another object.

Similar Messages

Doubt about scope of instance variable

Hi All,
i have a doubt about scope of instance variable.
if i declare a instance variable in servlet , i want to know whether it can be shared(means everywhere ) or not.
thanks in advance
Gopal

The servlet container will create one servlet object, and run multiple threads through its service() / doGet() / doPost() methods.
That means that any instance variables of the servlet are shared between multiple requests, and can cause problems with threads accessing the same variable..
To make your servlets thread-safe
1 - have no instance variables - only use local variables in the doGet/doPost method.
2 - use the session scope for storing variables you need over multiple calls.
Cheers,
evnafets

Scope of instance variables in servlets..

Hi all,
          Sorry for asking a dumb question..
          What is the scope of instance variables in a servlet? Is the scope is
          limited to thread?
          In other words, in the following example, i am setting "testStr", in one
          request and when i tried to access the same instance variable from another
          request, i am getting it as null. Does it mean instance variable is limited
          to that particular thread/request?
          thanks in advance..
          -ramu


Oops ... I had misunderstood and had the problem backwards ;-)
          > Is it known behavior? With registered servlet its working fine (a
          > instance variable is shared by all requests)
          I believe so; I typically deploy in a WAR so have not seen the problem that
          you describe. Servlets can be reloaded, so what you saw could have been
          caused bye a date/time mismatch between the .class file and the server's
          current time. On the other hand, that could be how WebLogic works.
          Peace,
          Cameron Purdy
          Tangosol, Inc.
          http://www.tangosol.com
          +1.617.623.5782
          WebLogic Consulting Available
          "Ramu" <[email protected]> wrote in message
          news:[email protected]...
          > Hi Purdy,
          >
          > I got it. I am testing the servlet as a unregistered servlet, which is
          > creating instance for every new request!!!, which created this whole
          > confusion. Is it known behavior? With registered servlet its working fine
          (a
          > instance variable is shared by all requests)
          >
          > > What theory? ;-) Instance variables are on the object, and the object
          can
          > > be used by multiple threads, thus allowing multiple threads to access
          the
          > > same instance variables.
          > what i mean by theory here is, all instance variables in servlet should
          be
          > shared by all requests. Now i got it sir.
          >
          > Thank you..
          > -ramu
          >
          >
          > >
          > > Peace,
          > >
          > > --
          > > Cameron Purdy
          > > Tangosol, Inc.
          > > http://www.tangosol.com
          > > +1.617.623.5782
          > > WebLogic Consulting Available
          > >
          > >
          > > "Ramu" <[email protected]> wrote in message
          > > news:[email protected]...
          > > > Hi,
          > > >
          > > > > No, an instance variable in a servlet class is not limited to a
          > thread.
          > > > There
          > > > > is exactly one copy of the servlet created in memory and all
          requests
          > > pass
          > > > > through the same instance, thus sharing any instance variables. A
          > > couple
          > > > of
          > > > > things to remember:
          > > > I totally agree with you, But i am wondering why my sample servlet(i
          am
          > > > attaching the file) is not sharing the instance variables across
          > > > threads/reqs. (in 1st request set some string to "testStr" instance
          > > > variable, in next request if you read the same instance variable, you
          > will
          > > > get null!!)
          > > > Our current code is having instance variables. But right now we are
          not
          > > > getting any problems. But as per theory, instance variables should be
          > > shared
          > > > across threads/requests..
          > > >
          > > > Any how we are changing our code to remove all instance variables.
          > > >
          > > > thanks,
          > > > -ramu
          > > >
          > > > >
          > > > > 1.) Using instance or class variables in servlets that are not
          > read-only
          > > > is not
          > > > > a good thing to do. This makes the servlet not thread-safe. To
          > > maintain
          > > > > variables across requests, sessions, etc., use the servlet-defined
          > > objects
          > > > to
          > > > > store the state (e.g., request, session, etc.).
          > > > >
          > > > > 2.) If you modify the servlet class on disk, WebLogic will reload
          the
          > > > servlet
          > > > > class thus discarding the old instance and creating a new one (of
          > > course,
          > > > this
          > > > > depends on some configuration parameters for servlet reloading).
          > > > >
          > > > > Hope this helps,
          > > > > Robert
          > > > >
          > > > > Ramu wrote:
          > > > >
          > > > > > Hi,
          > > > > > thanks for quick reply.
          > > > > > I am not at all using SingleThreadModel. See the following code.
          > > > > > In first request i am passing "abc" value to testStr. But in
          second
          > > > request,
          > > > > > I am getting null for testStr in second request. It looks like
          (for
          > > me)
          > > > for
          > > > > > non single threaded model also, scope of instance variables is
          > > limited
          > > > to
          > > > > > Thread/Request.. But as per theory, because its not single
          threaded
          > > > model,
          > > > > > only one instance should be there AND testStr(instace variables)
          > > should
          > > > be
          > > > > > shared across the all threads. But i am not able see that
          behaviour
          > > > here.
          > > > > > But if declare instance variable as static, o am able to share
          it
          > > > across
          > > > > > all threads/requests.
          > > > > >
          > > > > > note:
          > > > > > From browser i am setting testStr to "abc" with URL like
          > > > > > "localhost/test1?testStr=abc"
          > > > > > And 2nd req from browser is like "localhost/test1" (on server
          > output
          > > i
          > > > am
          > > > > > getting null for testStr)
          > > > > >
          > > > > > Any ideas?
          > > > > >
          > > > > > thanks,
          > > > > > -ravi
          > > > > >
          > > > > > import java.io.*;
          > > > > > import javax.servlet.*;
          > > > > > import javax.servlet.http.*;
          > > > > >
          > > > > > public class test1 extends HttpServlet
          > > > > > {
          > > > > > public String testStr;
          > > > > >
          > > > > > public void doGet (HttpServletRequest req, HttpServletResponse
          res)
          > > > > > throws ServletException, IOException
          > > > > > {
          > > > > > doPost(req, res);
          > > > > > }
          > > > > >
          > > > > > public void doPost (HttpServletRequest req,
          HttpServletResponse
          > > res)
          > > > > > throws ServletException, IOException
          > > > > > {
          > > > > > try {
          > > > > > res.setContentType("text/html");
          > > > > > PrintWriter out = res.getWriter();
          > > > > > if(req.getParameter("testStr") != null)
          > > > > > {
          > > > > > testStr = req.getParameter("testStr");
          > > > > > System.out.println("set testStr = " + testStr);
          > > > > > }
          > > > > > else{
          > > > > > System.out.println("get testStr = " + testStr);
          > > > > > }
          > > > > >
          > > > > > }
          > > > > > catch(Exception e){
          > > > > > e.printStackTrace();
          > > > > > }
          > > > > >
          > > > > > }
          > > > > > }
          > > > > >
          > > > > > "Cameron Purdy" <[email protected]> wrote in message
          > > > > > news:[email protected]...
          > > > > > > Yes or no, depending on if your servlet implements
          > > SingleThreadModel.
          > > > > > >
          > > > > > > See the servlet 2.2 spec for documentation on how many instances
          > of
          > > a
          > > > > > > servlet will be created. See the doc for the SingleThreadModel
          > > > interface.
          > > > > > >
          > > > > > > Peace,
          > > > > > >
          > > > > > > --
          > > > > > > Cameron Purdy
          > > > > > > Tangosol, Inc.
          > > > > > > http://www.tangosol.com
          > > > > > > +1.617.623.5782
          > > > > > > WebLogic Consulting Available
          > > > > > >
          > > > > > >
          > > > > > > "Ramu" <[email protected]> wrote in message
          > > > > > > news:[email protected]...
          > > > > > > > Hi all,
          > > > > > > >
          > > > > > > > Sorry for asking a dumb question..
          > > > > > > >
          > > > > > > > What is the scope of instance variables in a servlet? Is the
          > scope
          > > > is
          > > > > > > > limited to thread?
          > > > > > > >
          > > > > > > > In other words, in the following example, i am setting
          > "testStr",
          > > in
          > > > one
          > > > > > > > request and when i tried to access the same instance variable
          > from
          > > > > > another
          > > > > > > > request, i am getting it as null. Does it mean instance
          variable
          > > is
          > > > > > > limited
          > > > > > > > to that particular thread/request?
          > > > > > > >
          > > > > > > > thanks in advance..
          > > > > > > >
          > > > > > > > -ramu
          > > > > > > >
          > > > > > > >
          > > > > > > >
          > > > > > >
          > > > > > >
          > > > >
          > > >
          > > >
          > > >
          > >
          > >
          >
          >

Stateless Bean - scope of instance variable in EJB Timer call back function

Hi,
I would like to know on the scope of an instance variable of a Stateless Bean object,
when used in a EJB Timer call back.Let me explain this in more detail below.
I have a requirement to use a EJB Timer.
For this, I have created a stateless object since Timer creation needs to be done
from a stateless bean. I have a member variable "count" of the stateless bean class.
In the timer call back(ejbTimeout), I am able to use this count variable during
each time of the call back, and the value of this variable is also updated properly.
I have a few queries with respect to the above behaviour:
1) Does stateless bean object not get destroyed once the Timer is created from the Bean?
2) If the Bean object is not destroyed, then when does the bean object get destroyed?
3) If both (1) and (2) are not true, then can anyone explain on how the above behaviour is possible?
Thanks in advance,
Ulrich

Hi Ulrich,
The ejb timer is associated with the stateless session bean component, not with a particular bean instance. There is no formal relationship between the bean instance that called createTimer() and the bean instance on which the timer callback happens. If they're the same in your test run that's just a coincidence and not something your application should be depending on.
In the stateless session bean model, the container can create and destroy stateless session bean instances at any time. The container is free to pick any stateless session bean instance to service any client invocation or timer callback. If you need to pass context into a timer callback, one way to do it is via the timer "info" object. However, the info object is immutable so it wouldn't be a good match for a counter. You could of course always just use a database for any necessary coordinated state.
--ken

Servlet Instance Variable scope

Just want to clarify my understanding of instance variables in regards to Servlets.
public class TestServlet extends HttpServlet
    public String instVariable = "";
public void processRequest(HttpServletRequest request, HttpServletResponse response)
      instVariable = request.getParameter("param");
      response.sendRedirect( instVariable ) ;
}If two users both enter the processRequest logic at the same time, is it possible that they will both get the same
result? My understanding of this was that if they each execute the first line, then each execute the second
line, each user would be redirected to the same instVariable that was set by the second request.
What would be the easiest way to stop this from happening? syncronized? ThreadSafe?
I just want a simple clarification.
Thanks for the insight.

If two users both enter the processRequest logic at
the same time, is it possible that they will both get
the same
result? My understanding of this was that if they
each execute the first line, then each execute the
second
line, each user would be redirected to the same
instVariable that was set by the second request. Yes, it is possible, since there is only one instVariable.
What would be the easiest way to stop this from
happening? syncronized? ThreadSafe? The easiest way to avoid that is to simply not use an instance variable. Use a local variable, declared within your processRequest method. Each thread (i.e. each user of the servlet) has its own set of local variables.

Variables versus Request Scope

What are the best practices for using the variables scope
versus using the request scope when assigning variables.
In other words, when should I use <cfset variables.x =
'barf'> and when should I use <cfset request.x =
'barf'>?

SpiderFromMars wrote:
> What are the best practices for using the variables
scope versus using the
> request scope when assigning variables.
>
> In other words, when should I use <cfset variables.x
= 'barf'> and when
> should I use <cfset request.x = 'barf'>?
>
The variables scope is only accessible in the current
template. The
request scope is accessible in the current template and any
other
template, such as a custom tag or include file, that is used
to build
the current request.
I.E

<cfset variable.x = "foo">
<cfset request.x = "bar">
<cfoutput>#variable.x##request.x#</cfoutput>
<cf_myCustomTag>

<cfset variable.x = "bob">
<cfoutput>#variable.x##request.x#</cfoutput>

How can I use evaluate to get the instance variable in customized tag

1.
At first , I create a class called bean,and declared several params in it and do not define any getter function for the param.
class bean{
String param = "test";
SomeClass scObj = new SomeClass();
2.
The second ,I use
request.setAttribute("beanObj",new bean());
3.
And then I wanna use the customized tag to show a text box , then initialize it's value.
<salt:text name="param" value="beanObj.param">
<salt:text name="obj" value="beanObj.scObj.func()">
4.
I tried the evaluator provided by JexlContext ,Struts, JSTL and it seems that if I do not define the getter for the variable ,I can not get the bean's instance variable's value.
Expression e = ExpressionFactory.createExpression( value );
JexlContext jc = JexlHelper.createContext();
jc.getVars().put(strInitBeanName, request.getAttribute("beanObj"));
Object obj = e.evaluate(jc);
the result of the obj is null....
Can anybody recommand some other evaluator can get the value of a instance variable from an object?

do you have any other suggestion ? Nops, somebody else may have though. AFAIK, all lookups of the type
beanName.propertyNameuse reflection on the getXXX() methods to access the property.
Having said that, I guess you could write one though in a custom tag, using the same - reflection (you will ahve to rely on the java.lang.reflect.Field class quite heavily) - but that would be reinventing the wheel for most other functionality that you would have to include (like looking up the bean in scope etc)
cheers,
ram.

Clearing variable from Request object

Hi everyone,
After getting value from request.getParameter("var"), I want to clear this "var" variable from request scope. So that in the next coming statements if i again call the same request.getParameter("var") statement than it must return null
So how to handle this issue of clearing certain variable from request scope or flushing the whole request object

I don't know what you are trying to do but it sounds confused. I would suggest you read the parameter once, at the beginning of the code. Store it in a variable and use that variable as necessary. If you still need help then would you explain what you are trying to achieve here.

Instance variable to hold the element of a tag in the xml file

Hi I have an xml file that is handled using this parser
<attr id="MY_NAME" >
this parser hanled the above tag but now I want to have it handle
<attr id="MY_NAME" desc="GOOD">
but I need to create an instance variable to handle the desc element in the attr tag .
Can some one help me out as this is not my file and I am having trouble to do please......
import java.util.*;
import java.io.*;
import javax.xml.parsers.*;
import org.xml.sax.*;
import org.xml.sax.helpers.*;
   The SupportMatrix class provides static variables and methods to simplify
   the determination of whether or not a given attribute is supported for a
   certain object type (queue manager, channel, etc.), depending on the version
   and platform of the queue manager to which it belongs.
   The SupportMatrix class may not be instantiated. Its constructor is private.
   An instance of the class is created internally in the static initializer so
   that the XML parsing methods are available.
   A corresponding XML document, SupportMatrix.xml, is parsed to create the various
   HashMaps which contain the version/platform dependency information. A number of
   inner classes are used to represent the various elements of the XML matrix
   definition.
   Here's a sample document:
   
   <supportmatrix>
     
     <object classid="1">
       
       <version cmdlevel="base">
         
         <attr id="MQCA_Q_MGR_NAME">
           
           <support platforms="UNIX,WINDOWS,OS400,VMS,NSK" maxlen="48" type="MQCFST"/>
           <support platforms="MVS" maxlen="4" type="MQCFST"/>
         </attr>
         <attr id="MQCA_Q_MGR_DESC">
           
           <support platforms="all" maxlen="64" type="MQCFST"/>
         </attr>
         
         <attr id="MQIA_PLATFORM"/>
         <attr id="MQIA_COMMAND_LEVEL"/>
       </version>
       
       <version cmdlevel="520" include="base">
       </version>
     </object>
   </supportmatrix>
   The inner classes, and their hierarchical relationships are as follows:
     SupportObject - corresponds to the <object> element. Stored in a static HashMap, and
                     keyed by classid.
       VersionObject - corresponds to the <version> element. Stored in a HashMap instance
                       variable of the SupportObject class, keyed by cmdlevel.
         AttributeObject - corresponds to the <attr> element. Stored in a HashMap instance
                           variable of the VersionObject class, keyed by attribute name.
           PlatformObject - corresponds to the <support> element. Stored in HashMaps belonging
                            to the AttributeObjects, keyed by platform. A single PlatformObject
                            instance is created when the support tag is encountered. The
                            "platforms" attribute of the support element is then processed. For
                            each platform in the comma-delimited list, an entry is added to the
                            collection of PlatformObjects. This is to greatly simplify later
                            lookups.
   In order to support the 'include' feature of object and version elements, certain
   functions are recursive. If the attribute to be validated is not found for the passed
   cmdlevel, the 'parent' VersionObject is consulted by means of the 'include' value. If
   the chain of VersionObjects has been exhausted and the attribute in question has still not
   been located, the next SupportObject in the chain is consulted in a similar fashion.
public class SupportMatrix extends DefaultHandler {
    /** The objects collection holds all the SupportObjects, keyed by classid. */
    private static HashMap objects;
    /** xmlFile will name the xml document to be parsed. Note that using the
        default class loader expects the string to be the path to the file. It must
        NOT begin with the '/' character. */
    private static String xmlFile =
        ResourceManager.getApplicationProperties().getProperty("SupportMatrixFile");
    private Stack stack;
    /** This static initializer allocates the static objects collection, creates an
        instance of the SupportMatrix class for xml parsing purposes, and initiates
        the parse operation to populate the collection. */
    static {
        objects = new HashMap();
        // Create a parser and process the xml doc
        SupportMatrix handler = new SupportMatrix();
        InputSource is = null;
        try {
            is = new InputSource(ClassLoader.getSystemClassLoader().getResourceAsStream(xmlFile));
            XMLReader xmlReader =
                SAXParserFactory.newInstance().newSAXParser().getXMLReader();
            xmlReader.setFeature("http://xml.org/sax/features/namespaces", true);
            xmlReader.setContentHandler(handler);
            if (is == null) {
                System.err.println("No input stream, dammit");
            xmlReader.parse(is);
        } catch(Exception e) {
            e.printStackTrace();
    /** Private constuctor, used only for XML parsing. */
    private SupportMatrix() {
        stack = new Stack();
    /** Add a SupportObject instance to the objects collection. */
    private void addObject(SupportObject obj) {
        String key = obj.getClassId();
        objects.put(key, obj);
    /* DefaultHandler methods                                              */
    /** Not used. */
    public void characters(char[] ch, int start, int length) {}
    /** Not used. */
    public void endDocument() {}
    /** For the version, object, and attr elements, pop the top element of the stack. */
    public void endElement(String uri, String localName, String qName) {
        if (localName.equals("version") || localName.equals("object") || localName.equals("attr")) {
            stack.pop();
    /** Not used. */
    public void setDocumentLocator(Locator locator) {}
    /** Not used. */
    public void startDocument() {}
    /** Most of the work is done here. Create the appropriate inner class instance for
        element; for object, version, and attr, push the element onto the stack so that
        child elements may be added to their collections as needed. */
    public void startElement(String uri, String localName, String qName,
                             Attributes attributes) {
        String include = attributes.getValue("include");
        if (localName.equals("object")) {
            SupportObject obj = new SupportObject(attributes.getValue("classid"), include);
            addObject(obj);
            stack.push(obj);
        } else if ( localName.equals("version")) {
            VersionObject ver = new VersionObject(attributes.getValue("cmdlevel"), include);
            ((SupportObject)stack.peek()).addVersion(ver);
            stack.push(ver);
        } else if ( localName.equals("attr")) {
            AttributeObject a = new AttributeObject(attributes.getValue("id"));
            //String desc = StringFactory.getString(attributes.getValue("desc"));
            //if(desc != null)
               //     a.setAttribute();
            String readonly = attributes.getValue("readonly");
            String exclude = attributes.getValue("exclude");
            if (include != null && exclude != null) {
                Log.log(Log.ERROR, this, "include and exclude are mutually exclusive, exclude value ignored");
                exclude = null;
            if (include != null) {
                a.setCondition(include, true);
            if (exclude != null) {
                a.setCondition(exclude, false);
            if (readonly != null)
                a.setReadonly(readonly.equals("y"));
            ((VersionObject)stack.peek()).addAttr(a);
            stack.push(a);
        } else if (localName.equals("support")) {
            String platforms = attributes.getValue("platforms");
            String readonly = attributes.getValue("readonly");
            String maxlen = attributes.getValue("maxlen");
            String type = attributes.getValue("type");
            int attrType = 0;
            if (type != null) {
                if (type.equals("MQCFIN")) {
                    attrType = CMQCFC.MQCFT_INTEGER;
                } else if (type.equals("MQCFIL")) {
                    attrType = CMQCFC.MQCFT_INTEGER_LIST;
                } else if (type.equals("MQCFST")) {
                    attrType = CMQCFC.MQCFT_STRING;
                } else if (type.equals("MQCFSL")) {
                    attrType = CMQCFC.MQCFT_STRING_LIST;
                } else if (type.equals("EXBIN")) {
                    attrType = MqcConstants.EXCFT_BINARY;
                } else if (type.equals("EXPCF")) {
                    attrType = MqcConstants.EXCFT_PCF;
            PlatformObject p = null;
            if (readonly == null) {
                p = new PlatformObject(platforms);
            } else {
                p = new PlatformObject(platforms, readonly.equals("y"));
            String exclude = attributes.getValue("exclude");
            if (include != null && exclude != null) {
                Log.log(Log.ERROR, this, "include and exclude are mutually exclusive, exclude value ignored");
                exclude = null;
            if (include != null)
                p.setCondition(include, true);
            if (exclude != null)
                p.setCondition(exclude, false);
            if (attrType != 0)
                p.setType(attrType);
            if (maxlen != null)
                p.setLen(Integer.parseInt(maxlen));
            ((AttributeObject)stack.peek()).addPlatform(p);
    public static boolean isExported(int attribute, TopologyModelNode node) {
        String name = ResourceManager.getAttributeName(attribute);
        return isExported(name, node);
    public static boolean isExported(String attribute, TopologyModelNode node) {
        // Find the qmgr node to fetch platform and cmdlevel
        TopologyModelNode qmgr = node.getModel().getQMgrNode(node.getAddress());
        // If there's no qmgr for this node, it must be one of 'ours'.
        if (qmgr == null)
            return false;     // None of 'our' objects can be exported to MQSC.
        String classId = node.getClassId();
        String cmdLevel = qmgr.getAttributeValue("MQIA_COMMAND_LEVEL");
        String platform = qmgr.getAttributeValue("MQIA_PLATFORM");
        return isExported(attribute, classId, cmdLevel, platform, node);
    public static boolean isExported(int attribute, String classId, String cmdLevel, String platform,
                                     TopologyModelNode node) {
        String name = ResourceManager.getAttributeName(attribute);
        return isExported(name, classId, cmdLevel, platform, node);
    /** Determine if an attribute is exportable. The attribute name, the classid of the object to
        which it belongs, plus the command level and platform of the queue manager are all needed
        to make this determination.
        Start by finding the AttributeObject for the combination of attribute, classid, and
        command level. If we can't find the AttributeObject, we assume that the attribute
        is not exported. Otherwise, find out if it is exportable for the selected platform.
    public static boolean isExported(String attribute, String classId, String cmdLevel, String platform,
                                     TopologyModelNode node) {
        AttributeObject attr = getAttributeObject(attribute, classId, cmdLevel);
        if (attr == null) {
            return false;
        } else {
            return attr.isExported(platform, node);
    public static boolean isSupported(int attribute, TopologyModelNode node) {
        String name = ResourceManager.getAttributeName(attribute);
        return isSupported(name, node);
    public static boolean isSupported(String attribute, TopologyModelNode node) {
        // Find the qmgr node to fetch platform and cmdlevel
        TopologyModelNode qmgr = node.getModel().getQMgrNode(node.getAddress());
        // If there's no qmgr for this node, it must be one of 'ours'.
        if (qmgr == null)
            return true;
        String classId = node.getClassId();
        String cmdLevel = qmgr.getAttributeValue("MQIA_COMMAND_LEVEL");
        String platform = qmgr.getAttributeValue("MQIA_PLATFORM");
        return isSupported(attribute, classId, cmdLevel, platform);
    public static boolean isSupported(int attribute, String classId, String cmdLevel, String platform) {
        String name = ResourceManager.getAttributeName(attribute);
        return isSupported(name, classId, cmdLevel, platform);
    /** Determine if an attribute is supported. The attribute name, the classid of the object to
        which it belongs, plus the command level and platform of the queue manager are all needed
        to make this determination.
        Start by finding the SupportObject for the classid. If it isn't there, we make the assumption
        (for now) that the attribute is supported. The only classids for which this can occur are
        broker, agent, and the various container objects.
        Propagate the isSupported request to the chain of SupportObjects (based on 'include' values)
        until we get a 'true' result or we run out of SupportObjects. */
    public static boolean isSupported(String attribute, String classId, String cmdLevel, String platform) {
        if (attribute == null)
            return false;
        SupportObject obj = (SupportObject)objects.get(classId);
        // If the object type isn't even in the support matrix, we interpret that to
        // mean that it's a Broker or Agent, in which case all attributes are supported
        // at present.
        if (obj == null)
            return true;
        boolean result = false;
        while (result == false && obj != null) {
            result = obj.isSupported(attribute, cmdLevel, platform);
            if (result == false && obj.getInclude() != null) {
                obj = (SupportObject)objects.get(obj.getInclude());
            } else
                obj = null;
        return result;
    /** Locate an AttributeObject for a given attribute name, object type, and command level.
        This is a helper function for the getMaxLen and getType methods. */
    private static AttributeObject getAttributeObject(String attr, String classID, String cmdLevel) {
        AttributeObject result = null;
        SupportObject obj = (SupportObject)objects.get(classID);
        while (result == null && obj != null) {
            result = obj.getAttr(attr, cmdLevel);
            if (result == null && obj.getInclude() != null) {
                obj = (SupportObject)objects.get(obj.getInclude());
            } else
                obj = null;
        return result;
    /** Determine the maximum length for a given combintation of attribute name, object type,
        command level, and platform. If the AttributeObject can't be found, or if the length
        hasn't been set, return -1. */
    public static int getMaxLen(String attr, String classId, String cmdLevel, String platform) {
        AttributeObject a = getAttributeObject(attr, classId, cmdLevel);
        if (a == null)
            return -1;
        return a.getMaxLen(platform);
    /** Determine the PCF parm type for a given combintation of attribute name, object type,
        command level, and platform. If the AttributeObject can't be found, or if the length
        hasn't been set, return -1. */
    public static int getType(String attr, String classId, String cmdLevel, String platform) {
        AttributeObject a = getAttributeObject(attr, classId, cmdLevel);
        if (a == null)
            return -1;
        return a.getType(platform);
    /** Inner class to contain platform-specific info for an attribute. */
    class PlatformObject {
        /** This instance variable will contain the comma-delimited string of all
            platforms to which this object applies. */
        private String platform;
        private int maxlen;
        private String condition = null;
        private boolean include;
        private boolean readonly;
        private boolean lenSet;
        private int attrType;
        private boolean typeSet;
        public PlatformObject(String p, boolean readonly) {
            platform = p;
            this.readonly = readonly;
            lenSet = false;
            typeSet = false;
        public PlatformObject(String p) {
            this(p, false);
        public void setCondition(String condition, boolean include) {
            this.condition = condition;
            this.include = include;
        public boolean isReadonly() {
            return readonly;
        public boolean isExported(TopologyModelNode node) {
            if (condition != null) {
                boolean test = false;
                try {
                    test = Utilities.evaluateCondition(node, condition);
                } catch (Exception e) {}
                if (include ^ test)
                    return false;
            return !readonly;
        public void setLen(int len) {
            maxlen = len;
            lenSet = true;
        public void setType(int type) {
            attrType = type;
            typeSet = true;
        public String getPlatform() {
            return platform;
        public int getMaxLen() {
            if (!lenSet)
                return -1;
            return maxlen;
        public int getType() {
            if (!typeSet)
                return -1;
            return attrType;
    /** This class represents a specific MQSeries attribute. It can optionally contain
        instances of the PlatformObject class as needed. When the 'platforms' collection
        is empty, the attribute is supported on all platforms. It is also possible to
        include a PlatformObject for the 'all' platform, if specific attribute characteristics
        need representation. When the 'platforms' collection is non-empty, it will include one
        entry for each platform where the attribute is supported. */
    class AttributeObject {
        private String attribute;
        private String attrValue;
        private HashMap platforms;
        private String condition = null;
        private boolean include;
        private boolean readonly = false;
        public AttributeObject(String a) {
            this(a, false);
        public AttributeObject(String a, boolean readonly) {
            attribute = a;
            platforms = new HashMap();
            this.readonly = readonly;
        public void setCondition(String condition, boolean include) {
            this.condition = condition;
            this.include = include;
        public void setReadonly(boolean readonly) {
            this.readonly = readonly;
        public boolean isReadonly() {
            return readonly;
        public void addPlatform(PlatformObject p) {
            for (StringTokenizer st = new StringTokenizer(p.getPlatform(), ","); st.hasMoreTokens() ;) {
                platforms.put(st.nextToken(), p);
        public PlatformObject getPlatform(String platform) {
            PlatformObject p = (PlatformObject)platforms.get(platform);
            if (p == null)
                p = (PlatformObject)platforms.get("all");
            return p;
        public String getAttribute() {
            return attribute;
        public int getMaxLen(String platform) {
            PlatformObject p = getPlatform(platform);
            if (p == null)
                return -1;
            return p.getMaxLen();
        public int getType(String platform) {
            PlatformObject p = getPlatform(platform);
            if (p == null)
                return -1;
            return p.getType();
        public boolean isSupported(String platform) {
            if (platforms.isEmpty()) {
                return true;
            if (platforms.containsKey(platform)) {
                return true;
            if (platforms.containsKey("all")) {
                return true;
            return false;
        public boolean isExported(String platform, TopologyModelNode node) {
            if (readonly) {
                Log.log(Log.DEBUG, this, attribute + " is readonly, returning false");
                return false;
            if (condition != null) {
                Log.log(Log.DEBUG, this, "Testing condition = " + condition);
                boolean test = false;
                try {
                    test = Utilities.evaluateCondition(node, condition);
                    Log.log(Log.DEBUG, this, "Condition result is " + test);
                } catch (Exception e) {
                    Log.log(Log.ERROR, this, "Condition through an exception");
                if (include ^ test)
                    return false;
            if (platforms.isEmpty()) {
                return true;
            PlatformObject p = getPlatform(platform);
            if (p == null) {
                Log.log(Log.DEBUG, this, platform + " not found for " + attribute + ", returning false");
                return false;
            return p.isExported(node);
    /** This class represents a specific value of a queue manager's command level. A
        given instance of this class may 'include' a 'parent' instance through its
        include instance variable. The traversal of the parent/child hierarchy is
        delegated to the SupportObject class, since that is where the collection of
        VersionObjects lives. */
    class VersionObject {
        private String cmdLevel;
        private String include;
        private HashMap attributes;
        public VersionObject(String cmdLevel, String include) {
            this.cmdLevel = cmdLevel;
            this.include = include;
            attributes = new HashMap();
        public void addAttr(AttributeObject attr) {
            attributes.put(attr.getAttribute(), attr);
        public AttributeObject getAttr(String attr) {
            return (AttributeObject)attributes.get(attr);
        public String getCmdLevel() {
            return cmdLevel;
        public String getInclude() {
            return include;
        public boolean isSupported(String attr, String platform) {
            AttributeObject obj = (AttributeObject)attributes.get(attr);
            if (obj == null) {
                return false;
            } else
                return obj.isSupported(platform);
    /** This class represents an MQSeries object type, as identified by its classid, e.g.
        queue manager or local queue. This class implements an include facility similar to
        that described for the VersionObject. The traversal of that hierarchy is delegated
        to the static isSupported method, because the collection of SupportObject instances
        is a static variable of the SupportMatrix class. */
    class SupportObject {
        private String classId;
        private String include;
        private HashMap versions;
        public SupportObject(String classId, String include) {
            this.classId = classId;
            this.include = include;
            versions = new HashMap();
        public void addVersion(VersionObject obj) {
            String key = obj.getCmdLevel();
            versions.put(key, obj);
        public String getClassId() {
            return classId;
        public String getInclude() {
            return include;
        public boolean isSupported(String attr, String cmdLevel, String platform) {
            boolean result = false;
            VersionObject obj = (VersionObject)versions.get(cmdLevel);
            if (obj == null)
                obj = (VersionObject)versions.get("base");
            // I don't actually know what it means if obj is null at this point.
            // It probably can't happen.
            if (obj == null)
                return false;
            while (result == false && obj != null) {
                result = obj.isSupported(attr, platform);
                if (result == false && obj.getInclude() != null) {
                    obj = (VersionObject)versions.get(obj.getInclude());
                } else
                    obj = null;
            return result;
        public AttributeObject getAttr(String attr, String cmdLevel) {
            AttributeObject result = null;
            VersionObject obj = (VersionObject)versions.get(cmdLevel);
            if (obj == null)
                obj = (VersionObject)versions.get("base");
            // I don't actually know what it means if obj is null at this point.
            // It probably can't happen.
            if (obj == null)
                return null;
            while (result == null && obj != null) {
                result = obj.getAttr(attr);
                if (result == null && obj.getInclude() != null)
                    obj = (VersionObject)versions.get(obj.getInclude());
                else
                    obj = null;
            return result;
}

Are you the one who commented out the code you're looking for ?//String desc = StringFactory.getString(attributes.getValue("desc"));You just have to modify you AttributeObject class to hold a new field : String description. And then, it's up to you to create a new constructor or a new setter method.
Btw, this is not a Swing related question.

Binding: Instance variable loses value.

Hi all,
Just making my first steps into Objective-C, I've done a lot of C, C++ and C# on win & linux. Anyhow, I've been hacking away happily and discovered a peculiar behaviour, and I'm not sure if it's my code or some obscure bug in Xcode.
1. I have a Check Box(NSButton) directly bound to a BOOL instance variable called "checkValue" using KVC. The containing class is a custom NSView subclass.
2. I manually implemented the setter according to KVC naming rules "setCheckValue".
3. When debugging the UI (check box) calls the setter perfectly with the correct value, which shows up in the NSLog output.
4. I hooked up the action for the check box as well, and inside the action handler the instance variable reports the value correctly. Everything looks fine.
5. Now here's the rub. I put a mousedown event handler into the class as well, and it is called flawlessly when I click on the custom view. However, "checkValue" does not report the correctly set value.
So, how can a class instance variable, which is set and reports correctly elsewhere in the same scope, all of the sudden take on a nonsense value in a event handler? If a variable has a value set, it should be the same everywhere within the same scope!
Below is simplified code extracted from the original project for clarity. It produces exactly the same behaviour as the more complex project without the distracting code.
#import "CheckBoxHandler.h"
@implementation CheckBoxHandler
@synthesize checkValue;
//Apparently this is required for binding in NSView based classes
//The same behaviour occurs even if you remove this.
+(void)initialize
[self exposeBinding:@"checkValue"];
-(id)initWithFrame:(NSRect)frameRect
self = [super initWithFrame:frameRect];
if(!self)
return nil;
[self setCheckValue:YES];
return self;
//manual impelementation of KVC setter
-(void)setCheckValue:(BOOL)v
checkValue = v;
NSLog(@"Setter Called: checkValue is %d", checkValue);
//The action works fine as evidenced by Log output
//Check and uncheck the box a few times.
-(IBAction)checkBoxAction:(id)sender
NSLog(@"UI State:%d Ivar State: %d", [checkBox state], checkValue);
//Mouse clicking on the view calls into this event.
//The problem is the value reported by [self checkValue] OR checkValue directly
//do not match the UI state. In fact it always reports some nonsense value.
-(void)mouseDown:(NSEvent *)event
NSLog(@"Inside Mousedown: checkValue is: %d", [self checkValue]);
@end
I have a workaround, but it really bends my head when something doesn't behave as expected!

I have synthesized against "checkValue", although I manually implemented the setter so I could set a breakpoint and observe the value. I thought [self checkValue] and self.checkValue both simply call the same getter, just different syntax.
The setting of the value using the UI checkbox happens outside of the event call chain. I can check and uncheck the checkbox and the value changes correctly. The checkbox is in a separate space on the window, so clicking it does not activate mousedown on the view, this is correct behaviour. Clicking on the view does activate the mousedown event, this is done after I've set the checkbox so the value has been set well before the mousedown event. Thus it should already have the correct value in the event.
For completeness this is the interface file:
#import <Cocoa/Cocoa.h>
@interface CheckBoxHandler : NSView {
IBOutlet NSButton *checkBox;
BOOL checkValue;
-(IBAction)checkBoxAction:(id)sender;
@property (assign, readwrite) BOOL checkValue;
@end
I'll change everything to self.checkValue just for the excercise. Ok, done. checkValue still reports a value of 1 in the mousedown event regardless of the value set elsewhere.

JSP and Instance Variables

I have some questions about JSP presentation (Interactive Component Call in Screenflow):
- Only BPM Objects are possible to be mapped in JSP?
- Is possible to map two or more BPM Objects to the JSP?
- What is the difference of mapping using the variable "attributes" in argument mapping and the option "Select BPM object variable" in main task of Interactive Component Call activity?

I seem to be having a similar problem.
If I include this fragment, for an instance variable called "contacts" which is a BPMObject of type "ITSSContactRequest".
<%
Object r = request.getAttribute("contacts");
Class cl = r.getClass();
out.println(cl.getName());
%>
I get the following output:
xobject.ITSSContactManagement.ITSSContactRequest
and I can access the object via reflection:
<%
Object r = request.getAttribute("contacts");
Class cl = r.getClass();
out.println(cl.getName());
Method getGeneralContacts = cl.getMethod("getGeneralContacts", null);
Object rv = getGeneralContacts.invoke(r);
%>
and access the rv variable accordingly.
However, if I try and cast the variable directly:
<%
Object r = request.getAttribute("contacts");
Class cl = r.getClass();
out.println(cl.getName());
xobject.ITSSContactManagement.ITSSContactRequest rq = (xobject.ITSSContactManagement.ITSSContactRequest)r;
%>
I get the following error message:
"The task could not be successfully executed. Reason: 'fuego.web.execution.exception.InternalForwardException: UnExpected error during internal forward process.'.
See log file for more information [Error code: workspace-1258985548580] "
The same error occurs if I try and import the object via
<%@ page import="xobject.ITSSContactManagement.ITSSContactRequest" %>
Thanks for any help.

Stateful session bean destroying instance variables?

I'm trying to use a stateful session bean as some kind of login controller and to maintain the login id and access level across JSPs and HTMLs so that once logged in, all the JSPs can obtain the login name of the current user (String) and his access level (int).
I use the login.jsp to login and it successfully reports logging in with the correct access level retrieved from database. However, if I go to another JSP (testlogin.jsp), these 2 EJB instance variables are always destroyed and set to null and 0 when I access them again.
What am I missing that my stateful session bean is not saving these instance variables? Do I need to put them in some serializable value objects (create a help VO class?)
I suspected that on different JSP, I call the MemberControllerHome.create() method, it creates a new instance or something but if I don't use the create method how do I get a handle to MemberController at all?
MemberControllerBean.java
public class MemberControllerBean implements SessionBean {
     //initialize in ejbCreate.
     private MemberHome memberHome;
     SessionContext context;
     //Member currentLogin;
     //Current Login
     private String loginID;
     private int accessLevel;
     // Constructor
     public MemberControllerBean() {}
...some code in between...
public void login(String id, String password){
          try{
               Member member = null;
               member = memberHome.findByPrimaryKey(id);
               if(member.getMPassword().equals(password)){
                    this.loginID = member.getMID();
                    this.accessLevel = member.getMAccessLevel();
               else{
                    throw new EJBException("Login failed. Invalid member ID and/or password.");
          } catch (FinderException ex) {
               throw new EJBException("Login failed. Invalid member ID and/or password.");
     public void logout(){
          this.loginID = null;
          this.accessLevel = 4;
     public String getLoginID(){
          return this.loginID;
     public int getLoginAccessLevel(){
          return this.accessLevel;
login.jsp
String mID = request.getParameter("mID");
String mPassword = request.getParameter("mPassword");
out.println("20:" + mID + ":" + mPassword);
if(mID != null && mPassword != null){
     out.println("22:" + mID + ":" + mPassword);
     try{
          InitialContext ic = new InitialContext();
          MemberControllerHome home = (MemberControllerHome) ic.lookup("java:comp/env/ejb/MemberController");
          MemberController mc = home.create();
          out.println("26:Logging in as " + mID + " with " + mPassword);
          mc.login(mID, mPassword);
          out.println("28:" + mc.getLoginID() + "logged in successfully at level " +
               mc.getLoginAccessLevel() + ".");
     } catch (NamingException ex) {
          out.println("java:comp/env/ejb/MemberController not found.");
     } catch (EJBException ex) {
          out.println(ex.getMessage());
     } catch (Exception ex) {
          out.println(ex.getMessage());
testlogin.jsp
<%
try{
     InitialContext ic = new InitialContext();
     MemberControllerHome home = (MemberControllerHome) ic.lookup("java:comp/env/ejb/MemberController");
     MemberController mc = home.create();
     out.println("You are logged in as <b>" + mc.getLoginID() +
          "</b> at level <b>" + mc.getLoginAccessLevel() + "</b>.");
} catch (NamingException ex) {
     out.println("java:comp/env/ejb/MemberController not found.");
} catch (EJBException ex) {
     out.println(ex.getMessage());
} catch (Exception ex) {
     out.println(ex.getMessage());
%>

The key to the problem is that in testlogin.jsp a new stateful session bean is created. The new bean instance of course doesn't know the log-in information you stored in the old session bean. That is why the method returns null and 0 when called.
There are couple of ways to solve the issue. The easiest solution is to store the bean instance created in Login.jsp in the jsp's implicit HttpSession object. Because login.jsp and testlogin.jsp share the same session, the bean instance can be easily stored and retrieved.
Here is the code you need to have:
1. in login.jsp
session.setAttribute("MemberControllerBeanInstance", mc);
2. in testlogin.jsp
MemberController mc =
(MemberController) session.getAttribute("MemberControllerBeanInstance");
Hope it helps.

Servlet instance variables

This might be a dumb question, but I'll ask it anyway...
I have methods in my servlet to handle registration, specifically creating address, customer and order objects.
All the information needed for creating my objects is coming from the registration form.
Right now if I were to call the createAddress() method, I have to pass the request object.... createAddress(request);
Would it be "thread safe" to make an instance variable of the request and refer to it using getters/setters? Or would it be wiser (and best practice) to make instance variables for the request attributes (like firstName, lastName, etc.)? Or am I way off and shouldn't be doing any of the above?
Thanks for the help.

GB_java_guy wrote:
To answer you question, I think it's different, from what I've read, because request attributes are supposed to be thread safe and I'd be using the request attributes instead of the request object.You said something about "making instance variables for the request attributes." I don't know what you mean by that, but if it's instance variable in the servlet class, don't do it.
I have no clue what you mean by "request attirbutes intead of request object."
So are you saying I should just use the request object and pass that to my methods instead? In general, yes. In some cases you may want to pass individual pieces of it--e.g. if there's a method that doesn't need to know or care about the fact that you're operating in a servlet context, and just needs a couple values to do its job.

Page flow controller - instance variable thread safe?

I have page flow controller that is a subclass of org.apache.beehive.netui.pageflow.PageFlowController runing weblogic 921. The essence of my question is: is instance variable of page flow controller thread safe?
Here are the details. I have an instance variable “status” that stores the status of the patient, which is stored in the request. It sets the status with after the patient status is retrieved from database. The set method is not synchronized.
This works fine during normal test. But it failed during load test. Does a page flow controller instance shared among different requests? If so, how can I store the status for each request?
Thanks,
G T

Hello
You seem to put your question on the wrong forum
Oracle Beehive and Apache Beehive are two different products...
Have a look on http://beehive.apache.org
Cheers
Fred

Instance variables in Servlets.

Hi
Is it a good practice to use instance variable in servlet.
Please refer code snippet below.
public class ExcelAction extends HttpServlet {
private int var1 =0;
doGet () {
var1++;
fun1();
fun1 (){
var1++;
}Like in above code I have used an instance variable var1 because I wish the same to be accessible in all servlet functions.
I guess it is not a good practice, as different requests to this servlet at same time will result in multiple threads of this servlet. Which will make the state of var1 unsafe.
If this is correct then what are the alternates if I wish to share variables between functions in a servlet.
Thanks

money321 wrote:
Because in beginning I was not sure that Servlets instances are also actually threads.They are not not threads. Each call to doGet(), doPost() etc is called in a Thread and since there can be many simultaneous calls each having it's own thread a Servlet has to be thread safe.
My other question was specific to threads as I was trying to implement threads.Why?
>
But in this one I rather used servlets.
But apologies, as instance of servlet are also threads.As I said, they are not threads.
>
But still one last doubt.
Sabre if you could please clarify the same as well :How about you do some reading [http://java.sun.com/developer/onlineTraining/Servlets/Fundamentals/|http://java.sun.com/developer/onlineTraining/Servlets/Fundamentals/] and use Google.
>
in your option 2 and three I will have to pass request object to function fun().No. You will need access to the request object for 2 and the servlet context for 3. You need to pass something
If i am correct on this then is this too a better approach ?My preferred approach is 1 since it makes much of your code testable outside of a Servlet.

Scope of instance variables clarification requested

Similar Messages

Maybe you are looking for