Transient properties are easier to maintain since these don't have to persist across multiple requests. The only responsibility of the developer is to cleanup the client-specific state from the page and its embedded components before returning the page to the pool.

Implementing transient properties manually for pages.  Manually implementing transient properties is a little different in pages and components. AbstractPage, the parent of all pages, has a special initialize() method that can be used for initializing properties. This initialize() method will be invoked once when the page is first created and again at the end of every request, before detaching the page.

public class PageClass extends BasePage
{
    private String _message;
    
    public void setMessage(String message)
    {
        _message = message;
    }
    
    public String getMessage()
    {
        return _message;
    }
    
    protected void initialize()  
    {
        _message = "Some initial message.";
    }
    
    ...
}

Special method to initialize page properties.

Implementing transient properties manually for components.  Components do not have the equivalent of the initialize() method. Instead, they must register for an event notification to tell them when the page is being detached (prior to being stored back into the page pool).

public class ComponentClass extends BaseComponent implements PageDetachListener  
{
    private String _message;
    
    public void setMessage(String message)
    {
        _message = message;
    }
    
    public String getMessage()
    {
        return _message;
    }
    
    protected void initialize()  
    {
        _message = "Some initial message.";
    }
    
    protected void finishLoad()  
    {
        initialize();
    }
    
    public void pageDetached(PageEvent event)  
    {
        initialize();
    }

    ...
}

	The listener to be invoked during the page detach event. Tip Implementing PageDetachListener will automatically register the component for the detach event, there is no need for manual registration.
	Arbitrary method to initialize component state.
	finishLoad() is an AbstractComponent method that will be invoked at the end of the component loading process.
	pageDetached() will be invoked at the time of detaching the page from the request.

Implementing transient properties via <property-specification>.  With <property-specification> there is not much for the developer to do. The property accessor and mutator methods are provided by the framework at runtime. So if there is a need to get/set properties, the component may declare abstract accessors/mutators.

<component-specification class="devguide.ComponentClass">
    ...
    <property-specification name="message" type="java.lang.String" 
        initial-value="Some initial message." />
    ...
</component-specification>

	Tip
	Properties defined via <property-specification> are by default transient properties. There is no need to specify the persistent attribute.

package devguide;

public abstract class ComponentClass extends BaseComponent
{
    // Accessor methods for property "message", defined via <property-specification>
    public abstract void setMessage(String message);
    public abstract String getMessage();

    // Arbitrary method demonstrating the usage of the "message" property.
    public void someMethod()
    {
        if (getMessage() == null)
            setMessage("New message ...");
    }
    
    ...
}

With the <property-specification>, the framework enhances the ComponentClass and adds the necessary behavior to initialize the state of the component prior to returning the containing page to the pool. The ComponentClass needs to declare the abstract methods only if the class needs to access them to define its behavior.

Persistent properties are managed by a framework component external to the page - the page recorder. It is the responsibility of the page recorder to record the client-specific persistent state of the page in HttpSession (or other storage) and retrieve it when the same client returns back to the page. The responsibility of the developer is to notify the page recorder as to when to record the state (typically whenever the state changes), and to cleanup the client-specific state from the page and its embedded components before returning the page to the pool.

The notification takes the form of an invocation of the static method fireObservedChange() in the Tapestry class. This method is overloaded for all the scalar types, and for Object.

Implmenting persistent properties manually in pages. 

public class PageClass extends BasePage
{
    private int _itemsPerPage;
    
    public int getItemsPerPage()
    {
        return _itemsPerPage;
    }
    
    public void setItemsPerPage(int itemsPerPage)
    {
        _itemsPerPage = itemsPerPage;
        
        Tapestry.fireObservedChange(this, "itemsPerPage", itemsPerPage);
    }
    
    protected void initialize()
    {
        _itemsPerPage = 10;
    }
    
    ...
}

This sets up a property, itemsPerPage, with a default value of 10. If the value is changed (perhaps by a form or a listener method), the changed value will "stick" with the user who changed it, for the duration of their session.

Implementing persistent properties manually in components. 

public class ComponentClass extends BaseComponent implements PageDetachListener
{
    private String _myProperty;
    
    public void setMyProperty(String myProperty)
    {
        _myProperty = myProperty;
        
        Tapestry.fireObservedChange(this, "myProperty", myProperty);
    }
    
    public String getMyProperty()
    {
        return _myProperty;
    }
    
    protected void initialize()
    {
        _myProperty = "a default value";
    }
    
    protected void finishLoad()
    {
        initialize();
    }
    
    /**
     *  The method specified by PageDetachListener.
     */
    public void pageDetached(PageEvent event)
    {
        initialize();
    }
    
    ...
}

The only difference here is the property initialization as we have already seen in transient properties. Again, there is no particular need to do all this; using the <property-specification> element is far, far simpler.

Implementing persistent properties via <property-specification>.  Persistent properties have to be explicitly specified in the <property-specification> element via the persistent attribute.

<component-specification class="devguide.ComponentClass">
    ...
    <property-specification name="message" type="java.lang.String" 
        persistent="yes" initial-value="Some initial message." />
    ...
</component-specification>

The usage of the property in the component class is identical to the usage of transient properties we saw earlier.