well ankur!
Any JDO-enabled application will require at least one PersistenceManager (PM). This is obtained from the PersistenceManagerFactory for the datastore. A PersistenceManager is the key to all persistence operations in JDO. With it you can persist, update, delete, and retrieve objects from the datastore. A PersistenceManager has a single transaction.
for more inf check http://db.apache.org/jdo/pm.html

Answered by raj u , an ibibo Master, at 3:01 PM on September 12, 2008

public interface PersistenceManager

Persiste nceManager is the primary interface for JDO-aware application components. It is the factory for Query and Transaction instances, and contains methods to manage the life cycle of PersistenceCapable instances.

A PersistenceManager is obtained from the PersistenceManagerFactory (recommended) or by construction.

Answered by Sharad Singh , an ibibo Master, at 6:38 PM on September 11, 2008

At a present moment Informa library is providing wide variety of parsers. It also allows user to store his groups of channels, channels, items and other objects in persistent storages using Hiberate and JDO interfaces. However, there are some problems with the implementations. Despite the fact that all of implementations have similar interfaces for helper classes (ChannelBuilderIF and etc) and objects (ChannelGroupIF and etc), they still should be handled in implementation specific way. This means that if you wish to migrate from in-memory storage model to Hibernate you should be ready to change your client application code significantly.

Persistence Manager module is intended to hide the internal implementation complexities from developer and provide unified and well-defined interface to all persistent services. Persistence Manager itself will take care of initialization, transactions management and other specific things. It is also intended to solve the other big problem - multi-threading. Great number of applications suffer from incorrect work with persistence models in multi-threaded environment, having many unsynchronized sessions and objects floating in heap.

Structure of the module is extremely simple. Base part of the module has only two classes and one interface:

* PersistenceManagerIF - main interface of any Persistence Manager. This interface defines contract between client application and persistence management implementation. Interface provides methods, which are necessary to create groups of channels, channels and items, populate groups with channels and channels with items, delete each of them and perform some other valuable manipulations. The main benefit is that you don't need to know how things work internally, you just need to know what you wish to do.
* PersistenceManagerConfig - configuration storage. This is the factory for PersistenceManagerIF implementations. You can use this class to get manager object at run-time without knowing what implementation is used in particular. In other words, you specify what implementation to use by setting system properties and do not hard-code the names of classes and packages in code.
* PersistenceManagerException - type of exception, thrown in error cases by PersistenceManagerIF.


For more visit :

http://informa.sourceforg e.net/persistence_manager.html

Answered by Ashish Yadav , an ibibo Wizard, at 2:32 PM on September 10, 2008

The JDO PersistenceManager is the primary interface for JDO-aware application components. It is the factory for the query interface and contains methods for managing the life cycle of persistent instances.

The JDO PersistenceManager interface is designed to support a variety of environments and data sources, from small footprint, real-time embedded systems to large enterprise application servers. It might be a layer on top of a standard Connector implementation such as JDBC or JMS, or itself include connection management and distributed transaction support.

J2EE Connector support is optional. If it is not supported by a JDO implementation, then a constructor for the JDO PersistenceManager or PersistenceManagerFactory is required.

There are three primary environments in which the JDO PersistenceManager is designed to work:
bullet Non-managed (non-application server): minimum function, single transaction, single JDO PersistenceManager where compactness is important.
bullet Non-managed but where extended features are desired: multiple PersistenceManager instances may support multiple data sources, XA coordinated transactions, or nested transactions.
bullet Managed: where the full range of capabilities of an application server is required.

A JDO PersistenceManager instance supports one transaction at a time and uses one connection to the underlying data source at a time. The JDO PersistenceManager instance might use multiple transactions serially, and might use multiple connections serially. Therefore, to support multiple concurrent connection-oriented data sources in an application, multiple JDO PersistenceManager instances are required.
Each workspace of a Jackrabbit content repository uses separate persistence manager to store the content in that workspace. Also the Jackrabbit version handler uses a separate persistence manager. The persistence managers in use are configured in the Jackrabbit XML configuration files. The configured persistence managers are instantiated and initialized using the JavaBeans conventions.

Source: http://www.service-architectur e.com/database/articles/jdo_pe rsistence_manager.html

Answered by alok , an ibibo Master, at 11:47 AM on September 10, 2008

As you read in the guide for PersistenceManagerFactory, to control the persistence of your objects you will require at least one PersistenceManagerFactory. Once you have obtained this object you then use this to obtain a PersistenceManager. A PersistenceManager provides access to the operations for persistence of your objects. This short guide will demonstrate some of the more common operations.

You obtain a PersistenceManager as follows

PersistenceManager pm = pmf.getPersistenceManager();In general you will be performing all operations on a PersistenceManager within a transaction, whether your transactions are controlled by your J2EE container, by a framework such as Spring, or by locally defined transactions. In the examples below we will omit the transaction demarcation for clarity.




Persisting an Object


The main thing that you will want to do with the data layer of a JDO-enabled application is persist your objects into the datastore. As we mentioned earlier, a PersistenceManagerFactory represents the datastore where the objects will be persisted. So you create a normal Java object in your application, and you then persist this as follows

pm.makePersistent(obj);Thi s will result in the object being persisted into the datastore, though clearly it will not be persistent until you commit the transaction. The LifecycleState of the object changes from Transient to PersistentClean (after makePersistent), to Hollow (at commit).

Using an Objects identity


Once you have persisted an object, it has an "identity". This is a unique way of identifying it. You can obtain the identity by calling

Object id = pm.getObjectId(obj);So what ? Well the identity can be used to retrieve the object again at some other part in your application. So you pass the identity into your application, and the user clicks on some button on a web page and that button corresponds to a particular object identity. You can then go back to your data layer and retrieve the object as follows

Object obj = pm.getObjectById(id);
http:// www.jpox.org/docs/1_1/pm.html

Answered by Nishu's , an ibibo Master, at 9:17 AM on September 10, 2008

well;
public interface PersistenceManager
Provider for transactional services, such as object lifecycle management.
The Factory for PersistenceManager instances is the PersistenceRuntime.
Each persistence environment has to provide an implementation of interface PersistenceManager.

The implementation must map the calls and Exceptions defined in this interface to the persistence tools implementation of a persistence manager. This is most likely done via delegation.

Only one transaction at a time may be opened with beginTransaction(). If beginTransaction() is not explicitly called, the first write operation on the PersistenceManager will start the exclusive access to the storage. Read operations without beginTransaction() are prohibited and will throw PersistenceException

After commit() or rollback() no more operations can be executed on the calling instance. You have to request another instance from the PersistenceRuntime.

All persistent operations need to be specified with a TreeOptionType. It may have following values: SKELETON: only the entity itself is written

DEPENDENT: the entity itself and dependent associated entities are written

COMPLETE_TREE: the entity itself and all associated entities are written

Persistence manager interface. Persistence managers are internal Jackrabbit components that handle the persistent storage of content nodes and properties. A persistence manager knows how to retrieve the persistent states of content items and how to atomically save a set of changes to the persistent state.

Each workspace of a Jackrabbit content repository uses separate persistence manager to store the content in that workspace. Also the Jackrabbit version handler uses a separate persistence manager. The persistence managers in use are configured in the Jackrabbit XML configuration files. The configured persistence managers are instantiated and initialized using the JavaBeans conventions.
Persistence manager life cycle

The life cycle of a persistence manager instance contains four phases:

1. Instantiation, where the instance is created and possible configuration properties are set using the JavaBean conventions. During this phase the persistence manager should not attempt to reference any external resources.
2. Initialization, where the init method is invoked to bind the persistence manager with a given context.
3. Normal usage, where the various create, load, exists, and store methods of the persistence manager are used to manage the persistent content items.
4. Closing, where the close method is invoked to close the persistence manager and release all acquired resources.
public interface PersistenceManager
extends javax.jdo.PersistenceManager
An extension to the standard persistence manager interface including methods specific to TriActive JDO.
Applications should not use these methods.

Answered by Kishore , an ibibo Master, at 7:41 AM on September 10, 2008

Well ankur , public interface PersistenceManager

Persistence manager interface. Persistence managers are internal Jackrabbit components that handle the persistent storage of content nodes and properties. A persistence manager knows how to retrieve the persistent states of content items and how to atomically save a set of changes to the persistent state.

Each workspace of a Jackrabbit content repository uses separate persistence manager to store the content in that workspace. Also the Jackrabbit version handler uses a separate persistence manager. The persistence managers in use are configured in the Jackrabbit XML configuration files. The configured persistence managers are instantiated and initialized using the JavaBeans conventions.
Persistence manager life cycle

The life cycle of a persistence manager instance contains four phases:

1. Instantiation, where the instance is created and possible configuration properties are set using the JavaBean conventions. During this phase the persistence manager should not attempt to reference any external resources.
2. Initialization, where the init method is invoked to bind the persistence manager with a given context.
3. Normal usage, where the various create, load, exists, and store methods of the persistence manager are used to manage the persistent content items.
4. Closing, where the close method is invoked to close the persistence manager and release all acquired resources.

For more information , Please visit the source site :

http://jackrabbit.apache.org/a pi-1/org/apache/jackrabbit/core/sta te/PersistenceManager.html

Answered by Alok Gupta , an ibibo Guru, at 12:51 AM on September 10, 2008

What is a Persistence Manager (PM)?
The PM is an *internal* Jackrabbit component that handle the persistent storage of content nodes and properties. Each workspace of a Jackrabbit content repository uses a separate persistence manager to store the content in that workspace. Also the Jackrabbit version handler uses a separate persistence manager.

The persistence manager implementations to use are configured using the PersistenceManager configuration element within the Workspace configuration template (and the instantiated workspace configuration files) and the Versioning configuration element. The layout of a PersistenceManager configuration element is shown below.

<PersistenceManager class="...">
<param name="...">...</param>
...
</PersistenceManager>
Th e class attribute of the PersistenceManager element contains the fully qualified class name of the persistence manager implementation class. The class must implement the org.apache.jackrabbit.core.per sistence.PersistenceManager interface and have an empty default constructor. String properties can be assigned using the param elements according to the JavaBean conventions.

Answered by Keshto Patel , an ibibo Master, at 9:17 PM on September 09, 2008